runntime 0.1.0 → 0.2.0

package/dist/zoo/index.mjs

@@ -1,4 +1,6 @@
-import { $ as initRunntime, A as createMinilmEmbedCore, B as Linear, C as decodeTokens, F as createOpfsCache, H as Module, J as derivedTensor, K as warmUp, L as Conv1d, M as EMBEDDING_DIM, N as MINILM_L6, O as MinilmModel, P as models, Q as gpuExecutor, R as Embedding, T as createDetector, U as ModuleList, V as MultiHeadAttention, W as Parameter, Y as fromSafetensors, Z as evalValues, _ as buildRopeTables, a as MOBILENETV4_CROP_FRACTION, at as writeRows, c as createDetector$1, ct as add, d as move, dt as mul, f as moveTiedEmbedding, ft as silu, g as MoonshineDecoder, h as transformDecoder, ht as supportsF16, it as transpose, l as createTranscriber$1, lt as asinh, m as take, mt as defaultRoot, n as IMAGENET_MEAN, nt as gatherRowsFrom, o as DEPTHART_CONFIGS, ot as argmaxDot, p as qualify, pt as tensor, q as bufferSource, r as IMAGENET_STD, rt as slice, s as createEstimator, st as matmul, t as createClassifier, tt as chunk, u as fuseQkv, ut as gelu, v as splitIntoChunks, w as moonshineTokenizerAsset, z as LayerNorm } from "../classifier-ByH6OI6h.mjs";
+import { $ as derivedTensor, A as EMBEDDING_DIM$1, At as defaultRoot, B as Conv1d, C as createDetector, Ct as clamp$3, Dt as createMapToTexture, E as MinilmModel, Et as silu, F as messageOf, G as RMSNorm, H as LayerNorm, I as rethrowRunError, J as ModuleList, K as CpuParameter, L as models, M as asLoadError, Mt as RUNNTIME_ERROR_CODES, N as checkpointMismatch, Nt as RunntimeError, O as createMinilmEmbedCore, Ot as createImageToChw, P as isAbort, Pt as isRunntimeError, Q as bufferSource, R as createOpfsCache, St as asinh, Tt as mul, U as Linear, V as Embedding, W as MultiHeadAttention, Y as Parameter, Z as warmUp, _ as buildRopeTables, _t as reshape, a as MOBILENETV4_CROP_FRACTION, at as toArray, bt as writeRows, c as createDetector$1, ct as softmax, d as move, dt as sdpa, et as fromSafetensors, f as moveTiedEmbedding, ft as argmaxDot, g as MoonshineDecoder, gt as gatherRowsFrom, h as transformDecoder, ht as chunk, it as initRunntime, j as MINILM_L6, jt as supportsF16, kt as tensor, l as createTranscriber$1, lt as localAttention, m as take, mt as cat, n as IMAGENET_MEAN, nt as evalValues, o as DEPTHART_CONFIGS, ot as gluConv1d, p as qualify, pt as matmul, q as Module, r as IMAGENET_STD, rt as gpuExecutor, s as createEstimator, st as rmsNorm, t as createClassifier, u as fuseQkv, ut as rope, v as splitIntoChunks, vt as slice, wt as gelu, xt as add, yt as transpose, z as createReplayCache } from "../classifier-C6ZR3cyJ.mjs";
+import { d, isBuffer, isTexture } from "typegpu";
+import { Tokenizer } from "@huggingface/tokenizers";
 //#region src/core/lifetime.ts
 function createResourceScope() {
 	const tracked = [];
@@ -21,12 +23,13 @@ function createResourceScope() {
 //#region src/zoo/load.ts
 /** Loading helpers shared by every create<Task>() factory: one options
 *  shape, one way to open a weights file, one way to fetch a JSON asset. */
-/** Throws when the signal is already aborted. */
+/** Throws LOAD_ABORTED when the signal is already aborted. */
 function throwIfAborted(signal) {
-	if (signal?.aborted) throw new Error("model load aborted", { cause: signal.reason });
+	if (signal?.aborted) throw new RunntimeError("LOAD_ABORTED", "model load aborted", { cause: signal.reason });
 }
 /** Opens a safetensors file and reads its header. Tensor bytes download
-*  later, during loadStateDict. Every failure names the file it came from. */
+*  later, in loadStateDict. Fails with LOAD_FAILED, naming the file, or
+*  LOAD_ABORTED. */
 async function openWeights(modelPath, opts = {}) {
 	throwIfAborted(opts.signal);
 	try {
@@ -36,13 +39,14 @@ async function openWeights(modelPath, opts = {}) {
 			cacheId: opts.cacheId
 		});
 	} catch (err) {
-		throw new Error(`${typeof modelPath === "string" ? modelPath : "weights"}: ${err.message}`, { cause: err });
+		if (isRunntimeError(err)) throw err;
+		throw new RunntimeError("LOAD_FAILED", `${typeof modelPath === "string" ? modelPath : "weights"}: ${messageOf(err)}`, { cause: err });
 	}
 }
 /** Downloads and parses a JSON file (a tokenizer, a config). With a cache,
-*  the bytes are saved under `cacheId` (the file name by default) and the
-*  next load reads them from there. Every failure names the URL it came
-*  from. */
+*  the bytes are saved under `cacheId` (the file name by default) and reused
+*  on the next load. Fails with LOAD_FAILED, naming the URL, or
+*  LOAD_ABORTED. */
 async function fetchJson(url, opts = {}) {
 	throwIfAborted(opts.signal);
 	const download = async () => {
@@ -50,138 +54,1946 @@ async function fetchJson(url, opts = {}) {
 		try {
 			res = await fetch(url, { signal: opts.signal });
 		} catch (err) {
-			throw new Error(`${url}: ${err.message}`, { cause: err });
+			if (opts.signal?.aborted || isAbort(err)) throw asLoadError(err, opts.signal);
+			throw new RunntimeError("LOAD_FAILED", `${url}: ${messageOf(err)}`, { cause: err });
 		}
-		if (!res.ok) throw new Error(`${url}: HTTP ${res.status}`);
+		if (!res.ok) throw new RunntimeError("LOAD_FAILED", `${url}: HTTP ${res.status}`);
 		return new Uint8Array(await res.arrayBuffer());
 	};
 	const bytes = opts.cache ? await opts.cache.getOrCompute(`json/${opts.cacheId ?? url.split("/").pop()}`, download) : await download();
 	try {
 		return JSON.parse(new TextDecoder().decode(bytes));
 	} catch (err) {
-		throw new Error(`${url}: not valid JSON`, { cause: err });
-	}
-}
-function minilmTokenizerAsset(json, maxTokens) {
-	const bad = (why) => /* @__PURE__ */ new Error(`minilm tokenizer: ${why}`);
-	if (typeof json !== "object" || json === null) throw bad("not a JSON object");
-	if ("vocab" in json && Array.isArray(json.vocab)) {
-		const asset = json;
-		if (asset.version !== 1) throw bad(`unsupported asset version ${asset.version}`);
-		return maxTokens === void 0 ? asset : {
-			...asset,
-			maxWordpieces: maxTokens
+		throw new RunntimeError("LOAD_FAILED", `${url}: not valid JSON`, { cause: err });
+	}
+}
+//#endregion
+//#region src/zoo/tasks/audio/audioInput.ts
+/** Audio input helpers: an encoded clip or raw microphone samples in, the
+*  16 kHz mono Float32Array the speech models take out. Both use the
+*  browser's own decoder and resampler through an OfflineAudioContext, so
+*  they run in the browser only. Importing the file is safe anywhere, the
+*  browser objects appear only inside the functions. */
+/** Sample rate the speech models take. */
+const SPEECH_SAMPLE_RATE = 16e3;
+/** Decodes any clip the browser can play (wav, mp3, ogg, ...) to 16 kHz
+*  mono samples. Stereo is mixed down to one channel. */
+async function decodeAudio(data) {
+	const decoded = await new OfflineAudioContext(1, 1, SPEECH_SAMPLE_RATE).decodeAudioData(data);
+	if (decoded.numberOfChannels === 1) return decoded.getChannelData(0);
+	const mix = new OfflineAudioContext(1, decoded.length, SPEECH_SAMPLE_RATE);
+	const src = mix.createBufferSource();
+	src.buffer = decoded;
+	src.connect(mix.destination);
+	src.start();
+	return (await mix.startRendering()).getChannelData(0);
+}
+/** Resamples raw mono samples recorded at `sourceRate` to 16 kHz. Returns
+*  the input as is when it is already at 16 kHz. Use it on microphone
+*  samples, a lossy re-encode is not needed. */
+async function resampleAudio(samples, sourceRate) {
+	if (sourceRate === 16e3) return samples;
+	const frames = Math.ceil(samples.length * SPEECH_SAMPLE_RATE / sourceRate);
+	const off = new OfflineAudioContext(1, frames, SPEECH_SAMPLE_RATE);
+	const buf = off.createBuffer(1, samples.length, sourceRate);
+	buf.copyToChannel(samples, 0);
+	const src = off.createBufferSource();
+	src.buffer = buf;
+	src.connect(off.destination);
+	src.start();
+	return (await off.startRendering()).getChannelData(0);
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/audioEncoder.ts
+/** EmbeddingGemma 2 audio encoding: 16 kHz samples in, their token rows for
+*  the text model out, one eager forward of the audio tower per clip. */
+/** 20 ms frames every 10 ms, each zero-padded to the FFT size. */
+const FRAME = 320;
+const HOP = 160;
+const FFT = 512;
+const MEL_FLOOR = .001;
+const MAX_FREQUENCY = 8e3;
+/** Only the first 30 seconds of a clip count. */
+const MAX_SAMPLES = 30 * SPEECH_SAMPLE_RATE;
+/** Fewest samples that make one frame, about 10 ms. */
+const MIN_SAMPLES = 161;
+/** Mel frames of a clip of at least MIN_SAMPLES samples. The first frame is
+*  centered on sample 0. */
+const frameCount = (samples) => Math.floor((Math.min(samples, MAX_SAMPLES) - MIN_SAMPLES) / HOP) + 1;
+/** Tokens a clip of `samples` samples takes: each conv halves the frames,
+*  rounding up. Throws INVALID_ARGUMENT for a clip too short for one frame. */
+function audioTokens(samples) {
+	if (samples < MIN_SAMPLES) throw new RunntimeError("INVALID_ARGUMENT", `audio: a clip needs at least ${MIN_SAMPLES} samples, got ${samples}`);
+	return Math.ceil(Math.ceil(frameCount(samples) / 2) / 2);
+}
+let bank;
+/** Periodic Hann window, HTK mel triangles from 0 Hz to 8 kHz with no area
+*  normalization, and the FFT's tables. */
+function melBank(mels) {
+	if (bank?.filters.length === mels) return bank;
+	const window = new Float32Array(FRAME);
+	for (let n = 0; n < FRAME; n++) window[n] = .5 - .5 * Math.cos(2 * Math.PI * n / FRAME);
+	const bins = 257;
+	const mel = (f) => 2595 * Math.log10(1 + f / 700);
+	const hz = (m) => 700 * (10 ** (m / 2595) - 1);
+	const top = mel(MAX_FREQUENCY);
+	const edge = (i) => hz(top * i / (mels + 1));
+	const filters = Array.from({ length: mels }, (_, m) => {
+		const [lo, mid, hi] = [
+			edge(m),
+			edge(m + 1),
+			edge(m + 2)
+		];
+		const w = new Float64Array(bins);
+		let start = bins;
+		let end = 0;
+		for (let k = 0; k < bins; k++) {
+			const f = k * SPEECH_SAMPLE_RATE / 2 / 256;
+			const v = Math.max(0, Math.min((f - lo) / (mid - lo), (hi - f) / (hi - mid)));
+			if (v > 0) {
+				w[k] = v;
+				start = Math.min(start, k);
+				end = k + 1;
+			}
+		}
+		return {
+			start,
+			weights: w.slice(start, Math.max(start, end))
+		};
+	});
+	const order = new Uint16Array(FFT);
+	for (let i = 1, j = 0; i < FFT; i++) {
+		let bit = 256;
+		for (; j & bit; bit >>= 1) j ^= bit;
+		j ^= bit;
+		order[i] = j;
+	}
+	const cos = new Float64Array(FFT / 2);
+	const sin = new Float64Array(FFT / 2);
+	for (let k = 0; k < FFT / 2; k++) {
+		cos[k] = Math.cos(2 * Math.PI * k / FFT);
+		sin[k] = -Math.sin(2 * Math.PI * k / FFT);
+	}
+	bank = {
+		window,
+		filters,
+		order,
+		cos,
+		sin
+	};
+	return bank;
+}
+/** In-place radix-2 FFT of FFT points already in bit-reversed order. */
+function fft(re, im, cos, sin) {
+	for (let size = 2; size <= FFT; size <<= 1) {
+		const half = size >> 1;
+		const step = FFT / size;
+		for (let s = 0; s < FFT; s += size) for (let k = 0; k < half; k++) {
+			const c = cos[k * step];
+			const n = sin[k * step];
+			const a = s + k;
+			const b = a + half;
+			const tr = re[b] * c - im[b] * n;
+			const ti = re[b] * n + im[b] * c;
+			re[b] = re[a] - tr;
+			im[b] = im[a] - ti;
+			re[a] = re[a] + tr;
+			im[a] = im[a] + ti;
+		}
+	}
+}
+/** The first `frames` log-mel frames of `samples`, [frames, mels]. */
+function logMel(samples, frames, mels) {
+	const { window, filters, order, cos, sin } = melBank(mels);
+	const out = new Float32Array(frames * mels);
+	const re = new Float64Array(FFT);
+	const im = new Float64Array(FFT);
+	const mag = /* @__PURE__ */ new Float64Array(257);
+	for (let f = 0; f < frames; f++) {
+		re.fill(0);
+		im.fill(0);
+		const first = f * HOP - FRAME / 2;
+		for (let i = Math.max(0, -first); i < FRAME; i++) re[order[i]] = Math.fround(samples[first + i] * window[i]);
+		fft(re, im, cos, sin);
+		for (let k = 0; k < mag.length; k++) mag[k] = Math.sqrt(re[k] * re[k] + im[k] * im[k]);
+		filters.forEach(({ start, weights }, m) => {
+			let s = 0;
+			for (let k = 0; k < weights.length; k++) s += mag[start + k] * weights[k];
+			out[f * mels + m] = Math.log(s + MEL_FLOOR);
+		});
+	}
+	return out;
+}
+/** The first conv's taps [P + 1, 9]: a 3×3 window at stride 2, padded by 1,
+*  over the [frames, mels] image, then a row of zeros. */
+function convPatches(mel, frames, mels) {
+	const rows = Math.ceil(frames / 2);
+	const cols = mels / 2;
+	const out = new Float32Array((rows * cols + 1) * 9);
+	for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
+		const o = (r * cols + c) * 9;
+		for (let kh = 0; kh < 3; kh++) {
+			const y = 2 * r - 1 + kh;
+			if (y < 0 || y >= frames) continue;
+			for (let kw = 0; kw < 3; kw++) {
+				const x = 2 * c - 1 + kw;
+				if (x >= 0 && x < mels) out[o + kh * 3 + kw] = mel[y * mels + x];
+			}
+		}
+	}
+	return out;
+}
+/** The second conv's taps: for each of its output pixels, the 3×3 first-conv
+*  pixels it reads at stride 2, the zero row where it reads padding. */
+function convTaps(rows, cols) {
+	const outRows = Math.ceil(rows / 2);
+	const outCols = cols / 2;
+	const zero = rows * cols;
+	const out = new Float32Array(outRows * outCols * 9);
+	let o = 0;
+	for (let r = 0; r < outRows; r++) for (let c = 0; c < outCols; c++) for (let kh = 0; kh < 3; kh++) for (let kw = 0; kw < 3; kw++) {
+		const y = 2 * r - 1 + kh;
+		const x = 2 * c - 1 + kw;
+		out[o++] = y >= 0 && y < rows && x >= 0 && x < cols ? y * cols + x : zero;
+	}
+	return out;
+}
+/** A clip, mono samples at 16 kHz in [-1, 1], to its token rows
+*  [tokens · text hidden]. Only the first 30 s count. Runs on `ex` and trims
+*  its pool after. Throws INVALID_ARGUMENT for a clip shorter than one
+*  frame. */
+async function encodeAudio(model, samples, ex) {
+	const { mels } = model.cfg;
+	const tokens = audioTokens(samples.length);
+	const frames = frameCount(samples.length);
+	const act = model.input_proj.weight.shape.dtype === "f16" ? "f16" : "f32";
+	const patches = convPatches(logMel(samples, frames, mels), frames, mels);
+	const taps = convTaps(Math.ceil(frames / 2), mels / 2);
+	const inputs = {
+		patches: tensor(patches, {
+			elems: patches.length,
+			dtype: act,
+			dims: [patches.length / 9, 9]
+		}),
+		taps: tensor(taps, {
+			elems: taps.length,
+			dtype: "f32",
+			dims: [taps.length]
+		}),
+		tokens
+	};
+	try {
+		return await toArray(model.forward(inputs), ex);
+	} finally {
+		inputs.patches.buffer.destroy();
+		inputs.taps.buffer.destroy();
+		ex.trim();
+	}
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/config.ts
+const EMBEDDINGGEMMA2_TEXT = {
+	vocab: 262144,
+	hidden: 512,
+	ffn: 2048,
+	layers: 24,
+	heads: 4,
+	pleDim: 512,
+	embeddingDim: 768,
+	eps: 1e-6,
+	slidingWindow: 512,
+	layerTypes: Array.from({ length: 24 }, (_, i) => i % 6 === 5 ? "full" : "sliding"),
+	attention: {
+		sliding: {
+			headDim: 256,
+			kvHeads: 2,
+			theta: 1e4
+		},
+		full: {
+			headDim: 512,
+			kvHeads: 1,
+			theta: 1e6
+		}
+	}
+};
+const EMBEDDING_DIM = EMBEDDINGGEMMA2_TEXT.embeddingDim;
+/** Output sizes the model was trained to be cut to (Matryoshka). */
+const EMBEDDING_DIMS = [
+	768,
+	512,
+	256,
+	128
+];
+/** Longest input in tokens, `<bos>` and `<eos>` included, image and video
+*  tokens counted. The model takes 8192, this runner 2048. */
+const EMBEDDINGGEMMA2_MAX_TOKENS = 2048;
+const EMBEDDINGGEMMA2_VISION = {
+	hidden: 768,
+	ffn: 3072,
+	layers: 16,
+	heads: 12,
+	headDim: 64,
+	eps: 1e-6,
+	patch: 16,
+	pool: 3,
+	positions: 10240,
+	ropeTheta: 100
+};
+/** Token budgets an image may take, most tokens for the most detail. */
+const IMAGE_TOKEN_BUDGETS = [
+	70,
+	140,
+	280,
+	560,
+	1120
+];
+const EMBEDDINGGEMMA2_AUDIO = {
+	hidden: 1024,
+	ffn: 4096,
+	layers: 12,
+	heads: 8,
+	headDim: 128,
+	eps: 1e-6,
+	mels: 128,
+	convChannels: [128, 32],
+	window: 12,
+	logitCap: 50,
+	convKernel: 5,
+	residualWeight: .5,
+	outputDim: 1536
+};
+/** The instruction each task puts before the text (the checkpoint's
+*  sentence-transformers prompts). `query` and `document` are the two sides
+*  of search: queries get one, the texts searched get the other. */
+const EMBEDDINGGEMMA2_PROMPTS = {
+	query: "task: search result | query: ",
+	document: "title: none | text: ",
+	questionAnswering: "task: question answering | query: ",
+	factChecking: "task: fact checking | query: ",
+	classification: "task: classification | query: ",
+	clustering: "task: clustering | query: ",
+	similarity: "task: sentence similarity | query: ",
+	codeRetrieval: "task: code retrieval | query: "
+};
+//#endregion
+//#region src/zoo/tasks/cv/image.ts
+/** Raw CPU image types shared by every vision task. */
+/** Bytes per pixel for each format. */
+const FORMAT_CHANNELS = {
+	rgb: 3,
+	rgba: 4,
+	bgr: 3,
+	bgra: 4,
+	gray: 1
+};
+/** Throws unless `width` and `height` are positive integers. */
+function checkImageSize(width, height, what = "image") {
+	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) throw new RunntimeError("INVALID_ARGUMENT", `${what}: ${width}x${height} is not a positive size`);
+}
+/** Throws unless `image` has a positive size and exactly the bytes its
+*  size and format need. */
+function checkImageBuffer(image) {
+	const { data, width, height, format } = image;
+	checkImageSize(width, height);
+	const expected = width * height * FORMAT_CHANNELS[format];
+	if (data.length !== expected) throw new RunntimeError("INVALID_ARGUMENT", `image: ${data.length} bytes for ${width}x${height} ${format}, expected ${expected}`);
+}
+/** Wraps raw bytes as an ImageBuffer. Checks the size and the byte count. */
+function imageBuffer(data, width, height, format = "rgba") {
+	const image = {
+		data,
+		width,
+		height,
+		format,
+		layout: "hwc"
+	};
+	checkImageBuffer(image);
+	return image;
+}
+/** Views canvas ImageData as an ImageBuffer. No copy. */
+function imageBufferFromImageData(img) {
+	return {
+		data: img.data,
+		width: img.width,
+		height: img.height,
+		format: "rgba",
+		layout: "hwc"
+	};
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/stateDictHooks.ts
+/** Maps the HF EmbeddingGemma2Model checkpoint onto the text model and the
+*  vision and audio towers as lazy derived tensors; nothing is fetched here.
+*  Each keeps only its own tensors, so one checkpoint with every tower loads
+*  into any of them. */
+const SOURCE = "language_model.";
+const VISION_SOURCES = ["vision_tower.", "embed_vision."];
+const AUDIO_SOURCES = ["audio_tower.", "embed_audio."];
+/** Row r of each d-row head moves so (p, p + d/2) become (2p, 2p + 1). */
+function interleaveHeads(src, rows, cols, d) {
+	const out = new Float32Array(src.length);
+	for (let r = 0; r < rows; r++) {
+		const head = r - r % d;
+		const i = r % d;
+		const to = head + (i < d / 2 ? 2 * i : 2 * (i - d / 2) + 1);
+		out.set(src.subarray(r * cols, (r + 1) * cols), to * cols);
+	}
+	return out;
+}
+/** Each layer's RMSNorms, renamed `weight` → `scale`. */
+const LAYER_NORMS = [
+	"input_layernorm",
+	"post_attention_layernorm",
+	"pre_feedforward_layernorm",
+	"post_feedforward_layernorm"
+];
+/** Moves the tensors under `sources` out of `sd`. take() throws for a
+*  missing one, done() for any left unused. */
+function remap(sd, prefix, sources, what) {
+	const src = /* @__PURE__ */ new Map();
+	for (const [key, t] of sd.tensors) if (sources.some((s) => key.startsWith(s))) src.set(key, t);
+	sd.tensors.clear();
+	return {
+		take(name) {
+			const t = src.get(name);
+			if (!t) throw checkpointMismatch(what, `missing tensor '${name}'`);
+			src.delete(name);
+			return t;
+		},
+		put(name, t) {
+			sd.tensors.set(prefix ? `${prefix}.${name}` : name, t);
+		},
+		done() {
+			if (src.size) throw checkpointMismatch(what, `unused tensors: ${[...src.keys()].slice(0, 5)}`);
+		}
+	};
+}
+/** A weightless norm's ones. */
+const ones = (n) => derivedTensor([n], () => Promise.resolve(new Float32Array(n).fill(1)), 0);
+/** q, k and v in one weight. q and k rows go from the checkpoint's
+*  half-split rope layout to the kernel's interleaved pairs, per `block`
+*  rows. */
+function fusedQkv(wq, wk, wv, qRows, kvRows, hidden, block) {
+	const width = qRows + 2 * kvRows;
+	return derivedTensor([width, hidden], async () => {
+		const out = new Float32Array(width * hidden);
+		out.set(interleaveHeads(await wq.f32(), qRows, hidden, block), 0);
+		out.set(interleaveHeads(await wk.f32(), kvRows, hidden, block), qRows * hidden);
+		out.set(await wv.f32(), (qRows + kvRows) * hidden);
+		return out;
+	}, wq.byteLength + wk.byteLength + wv.byteLength);
+}
+/** q_norm and k_norm tiled over their heads and interleaved like
+*  fusedQkv, ones for v. */
+function fusedQkvNorm(nq, nk, heads, kvHeads, d, block) {
+	const width = (heads + 2 * kvHeads) * d;
+	return derivedTensor([width], async () => {
+		const out = new Float32Array(width).fill(1);
+		const qn = interleaveHeads(await nq.f32(), d, 1, block);
+		const kn = interleaveHeads(await nk.f32(), d, 1, block);
+		for (let h = 0; h < heads; h++) out.set(qn, h * d);
+		for (let h = 0; h < kvHeads; h++) out.set(kn, (heads + h) * d);
+		return out;
+	}, nq.byteLength + nk.byteLength);
+}
+/** The text model's mapping. PLE's hidden^-½ folds into its projection. */
+function transformEmbeddingGemma2StateDict(sd, prefix, cfg) {
+	const io = remap(sd, prefix, [SOURCE], "embeddinggemma2 state dict");
+	const take = (name) => io.take(SOURCE + name);
+	const { put } = io;
+	for (const [i, type] of cfg.layerTypes.entries()) {
+		const L = `layers.${i}`;
+		const { headDim: d, kvHeads } = cfg.attention[type];
+		const attn = (n) => take(`${L}.self_attn.${n}.weight`);
+		put(`${L}.qkv.weight`, fusedQkv(attn("q_proj"), attn("k_proj"), attn("v_proj"), cfg.heads * d, kvHeads * d, cfg.hidden, d));
+		put(`${L}.qkv_norm`, fusedQkvNorm(attn("q_norm"), attn("k_norm"), cfg.heads, kvHeads, d, d));
+		put(`${L}.o_proj.weight`, attn("o_proj"));
+		for (const n of [
+			"gate_proj",
+			"up_proj",
+			"down_proj"
+		]) put(`${L}.${n}.weight`, take(`${L}.mlp.${n}.weight`));
+		for (const n of ["per_layer_input_gate", "per_layer_projection"]) put(`${L}.${n}.weight`, take(`${L}.ple_block.${n}.weight`));
+		put(`${L}.post_per_layer_input_norm.scale`, take(`${L}.ple_block.post_per_layer_input_norm.weight`));
+		for (const n of LAYER_NORMS) put(`${L}.${n}.scale`, take(`${L}.${n}.weight`));
+		const s = take(`${L}.layer_scalar`);
+		put(`${L}.layer_scalar`, derivedTensor([1], () => s.f32(), s.byteLength));
+	}
+	const p = take("ple.per_layer_model_projection.weight");
+	const scale = cfg.hidden ** -.5;
+	put("ple.per_layer_model_projection.weight", derivedTensor(p.shape, async () => (await p.f32()).map((v) => v * scale), p.byteLength));
+	put("ple.per_layer_projection_norm.scale", take("ple.per_layer_projection_norm.weight"));
+	put("embed_tokens.weight", take("embed_tokens.weight"));
+	put("norm.scale", take("norm.weight"));
+	put("embedding_projection.weight", take("embedding_projection.weight"));
+	io.done();
+}
+/** The vision tower's mapping. Its 2D rope turns each half head on its
+*  own, so q and k interleave per half head. The position table splits
+*  into x and y, and the weightless norm gets ones. */
+function transformEmbeddingGemma2VisionStateDict(sd, prefix, cfg) {
+	const { take, put, done } = remap(sd, prefix, VISION_SOURCES, "embeddinggemma2 vision state dict");
+	const { hidden, heads, headDim: d, positions } = cfg;
+	put("input_proj.weight", take("vision_tower.patch_embedder.input_proj.weight"));
+	const table = take("vision_tower.patch_embedder.position_embedding_table");
+	let both;
+	const axis = (i) => derivedTensor([positions, hidden], async () => (await (both ??= table.f32())).slice(i * positions * hidden, (i + 1) * positions * hidden), table.byteLength / 2);
+	put("pos_x.weight", axis(0));
+	put("pos_y.weight", axis(1));
+	for (let i = 0; i < cfg.layers; i++) {
+		const S = `vision_tower.encoder.layers.${i}`;
+		const L = `layers.${i}`;
+		const attn = (n) => take(`${S}.self_attn.${n}.weight`);
+		const proj = (n) => take(`${S}.self_attn.${n}.linear.weight`);
+		const rows = heads * d;
+		put(`${L}.qkv.weight`, fusedQkv(proj("q_proj"), proj("k_proj"), proj("v_proj"), rows, rows, hidden, d / 2));
+		put(`${L}.qkv_norm`, fusedQkvNorm(attn("q_norm"), attn("k_norm"), heads, heads, d, d / 2));
+		put(`${L}.o_proj.weight`, proj("o_proj"));
+		for (const n of [
+			"gate_proj",
+			"up_proj",
+			"down_proj"
+		]) put(`${L}.${n}.weight`, take(`${S}.mlp.${n}.linear.weight`));
+		for (const n of LAYER_NORMS) put(`${L}.${n}.scale`, take(`${S}.${n}.weight`));
+	}
+	put("embedding_pre_projection_norm.scale", ones(hidden));
+	put("embedding_projection.weight", take("embed_vision.embedding_projection.weight"));
+	done();
+}
+/** The audio tower's mapping. Each clipped linear's four bounds become one
+*  CPU tensor [inMin, inMax, outMin, outMax]. q, k and v fuse into one
+*  weight; they share their bounds. Each layer's distance bias rows and q
+*  column scales are computed here, and the feed-forward residual weight
+*  folds into its post norm. */
+function transformEmbeddingGemma2AudioStateDict(sd, prefix, cfg) {
+	const what = "embeddinggemma2 audio state dict";
+	const { take, put, done } = remap(sd, prefix, AUDIO_SOURCES, what);
+	const { hidden, headDim, convKernel: K, window } = cfg;
+	const [c0, c1] = cfg.convChannels;
+	const S = "audio_tower.";
+	const scalar = async (t) => (await t.f32())[0];
+	const bounds = (name) => [
+		"input_min",
+		"input_max",
+		"output_min",
+		"output_max"
+	].map((b) => take(`${name}.${b}`));
+	const clip = (b) => derivedTensor([4], async () => Float32Array.from(await Promise.all(b.map(scalar))), 0);
+	const clipped = (from, to) => {
+		put(`${to}.weight`, take(`${from}.linear.weight`));
+		put(`${to}.clip`, clip(bounds(from)));
+	};
+	const reshaped = (t, shape, map) => derivedTensor(shape, async () => map ? map(await t.f32()) : t.f32(), t.byteLength);
+	const sub = `${S}subsample_conv_projection.`;
+	put("conv0.weight", reshaped(take(`${sub}layer0.conv.weight`), [c0, 9]));
+	put("norm0.weight", take(`${sub}layer0.norm.weight`));
+	put("conv1.weight", reshaped(take(`${sub}layer1.conv.weight`), [c1, 9 * c0], (w) => {
+		const out = new Float32Array(w.length);
+		for (let o = 0; o < c1; o++) for (let c = 0; c < c0; c++) for (let k = 0; k < 9; k++) out[(o * 9 + k) * c0 + c] = w[(o * c0 + c) * 9 + k];
+		return out;
+	}));
+	put("norm1.weight", take(`${sub}layer1.norm.weight`));
+	put("input_proj.weight", take(`${sub}input_proj_linear.weight`));
+	const half = hidden / 2;
+	const pe = new Float32Array(window * hidden);
+	for (let j = 0; j < window; j++) for (let i = 0; i < half; i++) {
+		const a = j * Math.exp(-i * Math.log(1e4) / (half - 1));
+		pe[j * hidden + i] = Math.sin(a);
+		pe[j * hidden + half + i] = Math.cos(a);
+	}
+	const qScale = headDim ** -.5 / Math.LN2;
+	for (let i = 0; i < cfg.layers; i++) {
+		const L = `layers.${i}`;
+		const T = `${S}layers.${i}`;
+		for (const ff of ["feed_forward1", "feed_forward2"]) {
+			put(`${L}.${ff}.pre_layer_norm.scale`, take(`${T}.${ff}.pre_layer_norm.weight`));
+			clipped(`${T}.${ff}.ffw_layer_1`, `${L}.${ff}.ffw_layer_1`);
+			clipped(`${T}.${ff}.ffw_layer_2`, `${L}.${ff}.ffw_layer_2`);
+			put(`${L}.${ff}.post_layer_norm.scale`, reshaped(take(`${T}.${ff}.post_layer_norm.weight`), [hidden], (w) => w.map((v) => v * cfg.residualWeight)));
+		}
+		const A = `${T}.self_attn`;
+		const qkv = [
+			"q_proj",
+			"k_proj",
+			"v_proj"
+		].map((n) => ({
+			w: take(`${A}.${n}.linear.weight`),
+			b: bounds(`${A}.${n}`)
+		}));
+		put(`${L}.qkv.weight`, derivedTensor([3 * hidden, hidden], async () => {
+			const out = new Float32Array(3 * hidden * hidden);
+			for (const [n, t] of qkv.entries()) out.set(await t.w.f32(), n * hidden * hidden);
+			return out;
+		}, qkv.reduce((s, t) => s + t.w.byteLength, 0)));
+		put(`${L}.qkv.clip`, derivedTensor([4], async () => {
+			const all = await Promise.all(qkv.map((t) => Promise.all(t.b.map(scalar))));
+			if (new Set(all.map(String)).size > 1) throw checkpointMismatch(what, `${A}: q, k and v have different bounds`);
+			return Float32Array.from(all.flat().slice(0, 4));
+		}));
+		clipped(`${A}.post`, `${L}.post`);
+		const rk = take(`${A}.relative_k_proj.weight`);
+		put(`${L}.rel`, derivedTensor([window, hidden], async () => {
+			const w = await rk.f32();
+			const out = new Float32Array(window * hidden);
+			for (let j = 0; j < window; j++) for (let o = 0; o < hidden; o++) {
+				let s = 0;
+				for (let n = 0; n < hidden; n++) s += pe[j * hidden + n] * w[o * hidden + n];
+				out[j * hidden + o] = s;
+			}
+			return out;
+		}, rk.byteLength));
+		put(`${L}.q_scale`, reshaped(take(`${A}.per_dim_scale`), [headDim], (s) => s.map((x) => qScale * Math.log1p(Math.exp(x)))));
+		const C = `${T}.lconv1d`;
+		put(`${L}.lconv.pre_layer_norm.scale`, take(`${C}.pre_layer_norm.weight`));
+		clipped(`${C}.linear_start`, `${L}.lconv.linear_start`);
+		put(`${L}.lconv.conv`, reshaped(take(`${C}.depthwise_conv1d.weight`), [K, hidden], (w) => {
+			const out = new Float32Array(w.length);
+			for (let c = 0; c < hidden; c++) for (let t = 0; t < K; t++) out[t * hidden + c] = w[c * K + t];
+			return out;
+		}));
+		put(`${L}.lconv.conv_norm.scale`, take(`${C}.conv_norm.weight`));
+		clipped(`${C}.linear_end`, `${L}.lconv.linear_end`);
+		for (const n of [
+			"norm_pre_attn",
+			"norm_post_attn",
+			"norm_out"
+		]) put(`${L}.${n}.scale`, take(`${T}.${n}.weight`));
+	}
+	put("output_proj.weight", take(`${S}output_proj.weight`));
+	put("output_proj.bias", take(`${S}output_proj.bias`));
+	put("embedding_pre_projection_norm.scale", ones(cfg.outputDim));
+	put("embedding_projection.weight", take("embed_audio.embedding_projection.weight"));
+	done();
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/audioModel.ts
+/** EmbeddingGemma 2 audio tower: a conformer over a clip's log-mel frames,
+*  one token per 40 ms, projected to the text model's width.
+*
+*  Two stride-2 convs shrink time and frequency 4×. Each layer is a
+*  half-weighted feed-forward, local attention over this token and the 11
+*  before it, a gated causal depthwise conv, a second feed-forward and a
+*  norm. Most linears clamp their input and output to bounds from the
+*  checkpoint. */
+/** k's scale in every score, fixed by the architecture. */
+const K_SCALE = Math.log1p(Math.E) / Math.LN2;
+/** A linear that clamps its input and output to the checkpoint's bounds. */
+var ClippedLinear = class extends Linear {
+	/** [inMin, inMax, outMin, outMax], read on the CPU. */
+	clip = new CpuParameter({
+		elems: 4,
+		dtype: "f32",
+		dims: [4]
+	});
+	constructor(inFeatures, outFeatures) {
+		super(inFeatures, outFeatures, { bias: false });
+	}
+	/** Bounds of the output. */
+	get outBounds() {
+		const [, , lo = -Infinity, hi = Infinity] = this.clip.data;
+		return {
+			lo,
+			hi
+		};
+	}
+	/** The matmul on the clamped input, its output left unclamped. */
+	unclamped(x) {
+		const [lo = -Infinity, hi = Infinity] = this.clip.data;
+		return super.forward(clamp$3(x, lo, hi));
+	}
+	forward(x) {
+		const { lo, hi } = this.outBounds;
+		return clamp$3(this.unclamped(x), lo, hi);
+	}
+};
+var FeedForward = class extends Module {
+	pre_layer_norm;
+	ffw_layer_1;
+	ffw_layer_2;
+	/** Its scale carries the residual weight. */
+	post_layer_norm;
+	constructor({ hidden, ffn, eps }) {
+		super();
+		this.pre_layer_norm = new RMSNorm(hidden, eps);
+		this.ffw_layer_1 = new ClippedLinear(hidden, ffn);
+		this.ffw_layer_2 = new ClippedLinear(ffn, hidden);
+		this.post_layer_norm = new RMSNorm(hidden, eps);
+	}
+	forward(x) {
+		const h = silu(this.ffw_layer_1.forward(this.pre_layer_norm.forward(x)));
+		const post = this.post_layer_norm;
+		return rmsNorm(this.ffw_layer_2.forward(h), post.scale.value, post.eps, { residual: x });
+	}
+};
+var LightConv = class extends Module {
+	pre_layer_norm;
+	/** The two GLU halves, value then gate. */
+	linear_start;
+	/** Depthwise taps [convKernel, hidden], oldest first. */
+	conv;
+	conv_norm;
+	linear_end;
+	constructor({ hidden, eps, convKernel }) {
+		super();
+		this.pre_layer_norm = new RMSNorm(hidden, eps);
+		this.linear_start = new ClippedLinear(hidden, 2 * hidden);
+		this.conv = new Parameter({
+			elems: convKernel * hidden,
+			dtype: "f32",
+			dims: [convKernel, hidden]
+		});
+		this.conv_norm = new RMSNorm(hidden, eps);
+		this.linear_end = new ClippedLinear(hidden, hidden);
+	}
+	forward(x) {
+		const z = this.linear_start.unclamped(this.pre_layer_norm.forward(x));
+		const g = gluConv1d(z, this.conv.value, this.linear_start.outBounds);
+		return add(this.linear_end.forward(silu(this.conv_norm.forward(g))), x);
+	}
+};
+var AudioLayer = class extends Module {
+	cfg;
+	feed_forward1;
+	norm_pre_attn;
+	/** q | k | v rows. */
+	qkv;
+	/** One bias row per key distance [window, hidden], f32. */
+	rel;
+	/** Scale of each column of q [headDim], f32. */
+	q_scale;
+	post;
+	norm_post_attn;
+	lconv;
+	feed_forward2;
+	norm_out;
+	constructor(cfg) {
+		super();
+		this.cfg = cfg;
+		const { hidden, headDim, window, eps } = cfg;
+		const f32 = (...dims) => new Parameter({
+			elems: dims.reduce((a, b) => a * b),
+			dtype: "f32",
+			dims
+		}, void 0, true);
+		this.feed_forward1 = new FeedForward(cfg);
+		this.norm_pre_attn = new RMSNorm(hidden, eps);
+		this.qkv = new ClippedLinear(hidden, 3 * hidden);
+		this.rel = f32(window, hidden);
+		this.q_scale = f32(headDim);
+		this.post = new ClippedLinear(hidden, hidden);
+		this.norm_post_attn = new RMSNorm(hidden, eps);
+		this.lconv = new LightConv(cfg);
+		this.feed_forward2 = new FeedForward(cfg);
+		this.norm_out = new RMSNorm(hidden, eps);
+	}
+	forward(x) {
+		const { heads, headDim, window, logitCap } = this.cfg;
+		x = this.feed_forward1.forward(x);
+		const qkv = this.qkv.forward(this.norm_pre_attn.forward(x));
+		const a = localAttention(qkv, this.rel.value, this.q_scale.value, {
+			heads,
+			headDim,
+			window,
+			kScale: K_SCALE,
+			softcap: logitCap
+		});
+		const norm = this.norm_post_attn;
+		x = rmsNorm(this.post.forward(a), norm.scale.value, norm.eps, { residual: x });
+		x = this.lconv.forward(x);
+		return this.norm_out.forward(this.feed_forward2.forward(x));
+	}
+};
+var EmbeddingGemma2AudioModel = class extends Module {
+	cfg;
+	conv0;
+	norm0;
+	conv1;
+	norm1;
+	input_proj;
+	layers;
+	output_proj;
+	embedding_pre_projection_norm;
+	embedding_projection;
+	constructor(cfg = EMBEDDINGGEMMA2_AUDIO) {
+		super();
+		this.cfg = cfg;
+		const { hidden, mels, eps, outputDim } = cfg;
+		const [c0, c1] = cfg.convChannels;
+		this.conv0 = new Linear(9, c0, { bias: false });
+		this.norm0 = new LayerNorm(c0, eps);
+		this.conv1 = new Linear(9 * c0, c1, { bias: false });
+		this.norm1 = new LayerNorm(c1, eps);
+		this.input_proj = new Linear(mels / 4 * c1, hidden, { bias: false });
+		this.layers = new ModuleList(Array.from({ length: cfg.layers }, () => new AudioLayer(cfg)));
+		this.output_proj = new Linear(hidden, outputDim);
+		this.embedding_pre_projection_norm = new RMSNorm(outputDim, eps);
+		this.embedding_projection = new Linear(outputDim, EMBEDDINGGEMMA2_TEXT.hidden, { bias: false });
+	}
+	/** One clip to its tokens [tokens, text hidden], ready to stand in for
+	*  the placeholder rows of the text model's input. */
+	forward(inp) {
+		const [c0, c1] = this.cfg.convChannels;
+		const relu = (v) => clamp$3(v, 0, Infinity);
+		const y0 = relu(this.norm0.forward(this.conv0.forward(inp.patches)));
+		const pixels = inp.taps.shape.elems / 9;
+		const y1 = reshape(gatherRowsFrom(y0, inp.taps), [pixels, 9 * c0]);
+		const y = relu(this.norm1.forward(this.conv1.forward(y1)));
+		let x = this.input_proj.forward(reshape(y, [inp.tokens, pixels / inp.tokens * c1]));
+		for (const layer of this.layers.items) x = layer.forward(x);
+		const out = this.embedding_pre_projection_norm.forward(this.output_proj.forward(x));
+		return this.embedding_projection.forward(out);
+	}
+	transformStateDict(sd, prefix) {
+		transformEmbeddingGemma2AudioStateDict(sd, prefix, this.cfg);
+	}
+};
+//#endregion
+//#region src/zoo/embeddinggemma2/rope.ts
+/** EmbeddingGemma 2 rope tables, in the kernel's interleaved-pair layout:
+*  entries 2p and 2p+1 hold pair p's angle. The q and k weights are permuted
+*  at load so these pairs are HF's half split (stateDictHooks). */
+/** cos and sin [positions, headDim] for theta. Row t depends only on t. */
+function ropeTables(positions, headDim, theta) {
+	const cos = new Float32Array(positions * headDim);
+	const sin = new Float32Array(positions * headDim);
+	for (let t = 0; t < positions; t++) for (let p = 0; p < headDim / 2; p++) {
+		const angle = t / theta ** (2 * p / headDim);
+		cos[t * headDim + 2 * p] = cos[t * headDim + 2 * p + 1] = Math.cos(angle);
+		sin[t * headDim + 2 * p] = sin[t * headDim + 2 * p + 1] = Math.sin(angle);
+	}
+	return {
+		cos,
+		sin
+	};
+}
+/** The vision tower's 2D rope: cos and sin [cols · rows, headDim] for a grid
+*  of patches in row-major order. The first half of each head turns with the
+*  patch's column, the second half with its row, each half a rope of
+*  headDim / 2. */
+function visionRopeTables(cols, rows, headDim, theta) {
+	const pairs = headDim / 2;
+	const halfPairs = pairs / 2;
+	const cos = new Float32Array(cols * rows * headDim);
+	const sin = new Float32Array(cols * rows * headDim);
+	for (let k = 0; k < cols * rows; k++) for (let p = 0; p < pairs; p++) {
+		const angle = (p < halfPairs ? k % cols : Math.floor(k / cols)) / theta ** (p % halfPairs / halfPairs);
+		cos[k * headDim + 2 * p] = cos[k * headDim + 2 * p + 1] = Math.cos(angle);
+		sin[k * headDim + 2 * p] = sin[k * headDim + 2 * p + 1] = Math.sin(angle);
+	}
+	return {
+		cos,
+		sin
+	};
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/embedCore.ts
+/** EmbeddingGemma 2 embed core: token ids in, pooled embeddings out.
+*
+*  The embedding table lives on the CPU, so a forward's input is the embedded
+*  rows, written with positions, segments and pool weights. Image, video and
+*  audio tokens arrive as rows from their tower and replace the rows of
+*  their placeholder ids. One input up to the largest bucket runs as a recorded
+*  replay per padded length; a longer input and a batch run eagerly. A
+*  batch packs its inputs into one sequence: segments keep them from
+*  attending to each other, positions restart per input and pick rope rows
+*  from one shared table, and each pool row averages one input. */
+/** Token counts a single input pads up to. Longer inputs run eagerly. */
+const EMBEDDINGGEMMA2_BUCKETS = [
+	16,
+	32,
+	64,
+	128,
+	192,
+	256,
+	384,
+	512
+];
+/** Packs inputs back to back into T rows: input b covers its own segment and
+*  pool row b. Rows past the inputs are one more segment, pooled by no one. */
+function fillInputs(model, T, inputs, out) {
+	const { hidden } = model.cfg;
+	out.x0.fill(0);
+	out.selector.fill(0);
+	let start = 0;
+	inputs.forEach(({ ids, media }, b) => {
+		const len = ids.length;
+		model.embedRows(ids, out.x0, start);
+		for (const { at, rows } of media) out.x0.set(rows, (start + at) * hidden);
+		for (let i = 0; i < len; i++) {
+			const t = start + i;
+			out.positions[t] = i;
+			out.segments[2 * t] = start;
+			out.segments[2 * t + 1] = start + len;
+			out.selector[b * T + t] = 1 / len;
+		}
+		start += len;
+	});
+	for (let t = start; t < T; t++) {
+		out.positions[t] = t - start;
+		out.segments[2 * t] = start;
+		out.segments[2 * t + 1] = T;
+	}
+}
+function createEmbeddingGemma2EmbedCore(model) {
+	const { hidden, embeddingDim, attention } = model.cfg;
+	const act = model.norm.scale.shape.dtype === "f16" ? "f16" : "f32";
+	const maxT = EMBEDDINGGEMMA2_MAX_TOKENS;
+	const table = (type) => {
+		const { headDim, theta } = attention[type];
+		const { cos, sin } = ropeTables(maxT, headDim, theta);
+		return {
+			cos: tensor(cos, [maxT, headDim]),
+			sin: tensor(sin, [maxT, headDim])
+		};
+	};
+	const tables = {
+		sliding: table("sliding"),
+		full: table("full")
+	};
+	const eager = gpuExecutor(defaultRoot());
+	const inputsOf = (planes, maxSegment) => {
+		const pick = (type) => ({
+			cos: gatherRowsFrom(tables[type].cos, planes.positions),
+			sin: gatherRowsFrom(tables[type].sin, planes.positions)
+		});
+		return {
+			x0: planes.x0,
+			rope: {
+				sliding: pick("sliding"),
+				full: pick("full")
+			},
+			selector: planes.selector,
+			segments: planes.segments,
+			maxSegment
+		};
+	};
+	const replays = createReplayCache({
+		buckets: EMBEDDINGGEMMA2_BUCKETS,
+		inputs: (T) => ({
+			x0: [T, hidden],
+			positions: [T, 1],
+			segments: [T, 2],
+			selector: [1, T]
+		}),
+		planeDtype: {
+			x0: act,
+			selector: act
+		},
+		captureFill: (T, scratch) => fillInputs(model, T, [{
+			ids: new Array(T).fill(0),
+			media: []
+		}], scratch),
+		build: (T, inp) => model.forward(inputsOf(inp, T))
+	});
+	/** One eager forward over inputs packed back to back. T rounds up to a
+	*  multiple of 4, so the attention score matmuls take the vec4 kernels. */
+	const runEager = async (inputs) => {
+		const T = Math.ceil(inputs.reduce((s, { ids }) => s + ids.length, 0) / 4) * 4;
+		const B = inputs.length;
+		const planes = {
+			x0: new Float32Array(T * hidden),
+			positions: new Float32Array(T),
+			segments: new Float32Array(2 * T),
+			selector: new Float32Array(B * T)
 		};
+		fillInputs(model, T, inputs, planes);
+		const upload = (data, rows, dtype) => tensor(data, {
+			elems: data.length,
+			dtype,
+			dims: [rows, data.length / rows]
+		});
+		const values = {
+			x0: upload(planes.x0, T, act),
+			positions: upload(planes.positions, T, "f32"),
+			segments: upload(planes.segments, T, "f32"),
+			selector: upload(planes.selector, B, act)
+		};
+		try {
+			const longest = Math.max(...inputs.map(({ ids }) => ids.length));
+			return await toArray(model.forward(inputsOf(values, longest)), eager);
+		} finally {
+			for (const v of Object.values(values)) v.buffer.destroy();
+			eager.trim();
+		}
+	};
+	const embedPooled = (input) => {
+		const T = replays.pick(input.ids.length);
+		return T === void 0 ? runEager([input]) : replays.run(T, (_, scratch) => fillInputs(model, T, [input], scratch));
+	};
+	const embedPooledBatch = async (inputs) => {
+		const packs = [];
+		let pack = [];
+		let tokens = maxT;
+		for (const input of inputs) {
+			if (tokens + input.ids.length > maxT) {
+				pack = [];
+				packs.push(pack);
+				tokens = 0;
+			}
+			pack.push(input);
+			tokens += input.ids.length;
+		}
+		const out = new Float32Array(inputs.length * embeddingDim);
+		let row = 0;
+		for (const pack of packs) {
+			out.set(await runEager(pack), row * embeddingDim);
+			row += pack.length;
+		}
+		return out;
+	};
+	const warmBuckets = async (probe) => {
+		for (const T of EMBEDDINGGEMMA2_BUCKETS) await replays.run(T, (_, scratch) => fillInputs(model, T, [probe], scratch));
+	};
+	return {
+		embedPooled,
+		embedPooledBatch,
+		warmBuckets,
+		dispose() {
+			replays.dispose();
+			eager.dispose();
+			for (const { cos, sin } of Object.values(tables)) {
+				cos.buffer.destroy();
+				sin.buffer.destroy();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/model.ts
+/** EmbeddingGemma 2 text model: a bidirectional Gemma encoder with
+*  per-layer embeddings (PLE), mean pooled and projected to 768.
+*
+*  Every layer is attention, a GeGLU MLP and a PLE block, each between a pre
+*  and a post RMSNorm. Five sliding layers (head 256, two kv heads) alternate
+*  with one full layer (head 512, one kv head). q, k and v are RMS-normed per
+*  head, so scores carry no 1/√d scale.
+*
+*  Built for few dispatches: q/k/v are one matmul, their per-head norms one
+*  grouped RMSNorm, and every post-norm also adds the residual. GELU rides
+*  the gate matmul's epilogue. Long inputs run attention per head as two
+*  matmuls around a masked softmax, short ones as one sdpa. */
+/** Longest-input length from which attention runs on matmuls. */
+const MATMUL_ATTENTION_MIN_SEGMENT = 256;
+/** Past this many rows a sliding layer keeps sdpa, which skips the keys
+*  outside its window. */
+const MATMUL_ATTENTION_MAX_SLIDING_ROWS = 1024;
+var Layer = class extends Module {
+	cfg;
+	type;
+	input_layernorm;
+	/** q | k | v rows, with q and k permuted for the interleaved rope. */
+	qkv;
+	/** q_norm tiled per q head, k_norm per kv head, ones for v. */
+	qkv_norm;
+	o_proj;
+	post_attention_layernorm;
+	pre_feedforward_layernorm;
+	gate_proj;
+	up_proj;
+	down_proj;
+	post_feedforward_layernorm;
+	per_layer_input_gate;
+	per_layer_projection;
+	post_per_layer_input_norm;
+	/** One number that scales the layer's output; read on the CPU. */
+	layer_scalar;
+	constructor(cfg, type) {
+		super();
+		this.cfg = cfg;
+		this.type = type;
+		const { hidden, heads, ffn, pleDim, eps } = cfg;
+		const { headDim, kvHeads } = cfg.attention[type];
+		const width = (heads + 2 * kvHeads) * headDim;
+		const norm = () => new RMSNorm(hidden, eps);
+		this.input_layernorm = norm();
+		this.qkv = new Linear(hidden, width, { bias: false });
+		this.qkv_norm = new Parameter({
+			elems: width,
+			dtype: "f32",
+			dims: [width]
+		});
+		this.o_proj = new Linear(heads * headDim, hidden, { bias: false });
+		this.post_attention_layernorm = norm();
+		this.pre_feedforward_layernorm = norm();
+		this.gate_proj = new Linear(hidden, ffn, {
+			bias: false,
+			activation: "geluTanh"
+		});
+		this.up_proj = new Linear(hidden, ffn, { bias: false });
+		this.down_proj = new Linear(ffn, hidden, { bias: false });
+		this.post_feedforward_layernorm = norm();
+		this.per_layer_input_gate = new Linear(hidden, pleDim, {
+			bias: false,
+			activation: "geluTanh"
+		});
+		this.per_layer_projection = new Linear(pleDim, hidden, { bias: false });
+		this.post_per_layer_input_norm = norm();
+		this.layer_scalar = new CpuParameter({
+			elems: 1,
+			dtype: "f32",
+			dims: [1]
+		});
 	}
-	const hf = json;
-	if (hf.model?.type !== "WordPiece" || typeof hf.model.vocab !== "object") throw bad("expected a WordPiece tokenizer.json or a version 1 asset");
-	const entries = Object.entries(hf.model.vocab);
-	const vocab = new Array(entries.length);
-	for (const [token, id] of entries) vocab[id] = token;
+	forward(x, perLayer, inp) {
+		const { heads, eps, slidingWindow } = this.cfg;
+		const { headDim: d, kvHeads } = this.cfg.attention[this.type];
+		const { cos, sin } = inp.rope[this.type];
+		const window = this.type === "sliding" ? slidingWindow : Infinity;
+		const postNorm = (norm, y, residual, scale) => rmsNorm(y, norm.scale.value, norm.eps, {
+			residual,
+			scale
+		});
+		const qkv = this.qkv.forward(this.input_layernorm.forward(x));
+		const n = rmsNorm(qkv, this.qkv_norm.value, eps, { group: d });
+		const roped = (start, width) => rope(n, cos, sin, {
+			headDim: d,
+			srcStart: start,
+			width
+		});
+		const vStart = (heads + kvHeads) * d;
+		const rows = x.shape.dims[0];
+		const perHead = inp.maxSegment >= MATMUL_ATTENTION_MIN_SEGMENT && (this.type === "full" || rows <= MATMUL_ATTENTION_MAX_SLIDING_ROWS);
+		let a;
+		if (perHead) {
+			const kT = Array.from({ length: kvHeads }, (_, h) => transpose(roped((heads + h) * d, d)));
+			const v = Array.from({ length: kvHeads }, (_, h) => slice(n, 1, vStart + h * d, vStart + (h + 1) * d));
+			const group = heads / kvHeads;
+			const mask = {
+				segments: inp.segments,
+				windowLeft: window,
+				windowRight: window
+			};
+			const outs = Array.from({ length: heads }, (_, h) => {
+				const g = Math.floor(h / group);
+				return matmul(softmax(matmul(roped(h * d, d), kT[g]), mask), v[g]);
+			});
+			a = cat(outs, 1);
+		} else a = sdpa(roped(0, heads * d), roped(heads * d, kvHeads * d), slice(n, 1, vStart, vStart + kvHeads * d), {
+			qHeads: heads,
+			kvHeads,
+			headDim: d,
+			windowLeft: window,
+			windowRight: window,
+			segments: inp.segments,
+			maxSegment: inp.maxSegment
+		});
+		x = postNorm(this.post_attention_layernorm, this.o_proj.forward(a), x);
+		const f = this.pre_feedforward_layernorm.forward(x);
+		const m = this.down_proj.forward(mul(this.gate_proj.forward(f), this.up_proj.forward(f)));
+		x = postNorm(this.post_feedforward_layernorm, m, x);
+		const g = mul(this.per_layer_input_gate.forward(x), perLayer);
+		const p = this.per_layer_projection.forward(g);
+		return postNorm(this.post_per_layer_input_norm, p, x, this.layer_scalar.data[0]);
+	}
+};
+var Ple = class extends Module {
+	cfg;
+	per_layer_model_projection;
+	per_layer_projection_norm;
+	constructor(cfg) {
+		super();
+		this.cfg = cfg;
+		const { hidden, layers, pleDim, eps } = cfg;
+		this.per_layer_model_projection = new Linear(hidden, layers * pleDim, { bias: false });
+		this.per_layer_projection_norm = new RMSNorm(pleDim, eps);
+	}
+	/** [T, hidden] to [T, layers·pleDim], each layer's slice RMS-normed. The
+	*  hidden^-½ scale is folded into the projection at load. */
+	forward(x) {
+		const norm = this.per_layer_projection_norm;
+		return rmsNorm(this.per_layer_model_projection.forward(x), norm.scale.value, norm.eps, { group: this.cfg.pleDim });
+	}
+};
+var EmbeddingGemma2Model = class extends Module {
+	cfg;
+	embed_tokens;
+	ple;
+	layers;
+	norm;
+	embedding_projection;
+	constructor(cfg = EMBEDDINGGEMMA2_TEXT) {
+		super();
+		this.cfg = cfg;
+		this.embed_tokens = new Embedding(cfg.vocab, cfg.hidden, { device: "cpu" });
+		this.ple = new Ple(cfg);
+		this.layers = new ModuleList(cfg.layerTypes.map((type) => new Layer(cfg, type)));
+		this.norm = new RMSNorm(cfg.hidden, cfg.eps);
+		this.embedding_projection = new Linear(cfg.hidden, cfg.embeddingDim, { bias: false });
+	}
+	/** Token ids to input rows [ids.length · hidden], scaled by √hidden,
+	*  written into `out` at row `offset`. */
+	embedRows(ids, out, offset) {
+		const rows = this.embed_tokens.gather(ids);
+		const s = Math.sqrt(this.cfg.hidden);
+		const base = offset * this.cfg.hidden;
+		for (let i = 0; i < rows.length; i++) out[base + i] = rows[i] * s;
+	}
+	/** Packed inputs to their pooled, projected embeddings [B, embeddingDim],
+	*  not yet unit length. */
+	forward(inp) {
+		const perLayer = this.ple.forward(inp.x0);
+		const pd = this.cfg.pleDim;
+		let x = inp.x0;
+		this.layers.items.forEach((layer, i) => {
+			x = layer.forward(x, slice(perLayer, 1, i * pd, (i + 1) * pd), inp);
+		});
+		return this.embedding_projection.forward(matmul(inp.selector, this.norm.forward(x)));
+	}
+	transformStateDict(sd, prefix) {
+		transformEmbeddingGemma2StateDict(sd, prefix, this.cfg);
+	}
+};
+//#endregion
+//#region src/zoo/embeddinggemma2/tokenizer.ts
+/** Gemma tokenizer, encode-only: text → piece ids, without <bos> and <eos>,
+*  which the caller places. tokenizers.js runs the Hub's tokenizer.json. */
+const isBpeTokenizerJson$1 = (json) => typeof json === "object" && json !== null && "model" in json && typeof json.model === "object" && json.model !== null && "type" in json.model && json.model.type === "BPE";
+/** Builds the tokenizer from a Hugging Face tokenizer.json of the Gemma
+*  BPE kind. Throws CHECKPOINT_MISMATCH for any other file. */
+function createEmbeddingGemma2Tokenizer(json) {
+	const bad = (why) => checkpointMismatch("embeddinggemma2 tokenizer", why);
+	if (!isBpeTokenizerJson$1(json)) throw bad("expected a BPE tokenizer.json");
+	const tokenizer = new Tokenizer(json, {});
 	const idOf = (token) => {
-		const id = hf.model.vocab[token];
+		const id = tokenizer.token_to_id(token);
 		if (id === void 0) throw bad(`vocab has no ${token}`);
 		return id;
 	};
 	return {
-		version: 1,
-		doLowerCase: hf.normalizer?.lowercase ?? true,
-		maxWordpieces: maxTokens ?? 256,
-		clsId: idOf("[CLS]"),
-		sepId: idOf("[SEP]"),
-		padId: idOf("[PAD]"),
-		unkId: idOf("[UNK]"),
-		vocab
+		bosId: idOf("<bos>"),
+		eosId: idOf("<eos>"),
+		padId: idOf("<pad>"),
+		boiId: idOf("<|image>"),
+		eoiId: idOf("<image|>"),
+		boaId: idOf("<|audio>"),
+		eoaId: idOf("<audio|>"),
+		encode: (text) => tokenizer.encode(text, { add_special_tokens: false }).ids
+	};
+}
+//#endregion
+//#region src/zoo/tasks/cv/ops/point.ts
+/** The resize as numbers: how many input pixels one image pixel takes, and
+*  where the image's top-left corner lands inside the input. */
+function resizeTransform(options) {
+	const { from, to, resizeMode } = options;
+	switch (resizeMode) {
+		case "stretch": return {
+			scaleX: from.width / to.width,
+			scaleY: from.height / to.height,
+			offsetX: 0,
+			offsetY: 0
+		};
+		case "letterbox": {
+			const scale = Math.min(from.width / to.width, from.height / to.height);
+			return {
+				scaleX: scale,
+				scaleY: scale,
+				offsetX: (from.width - to.width * scale) / 2,
+				offsetY: (from.height - to.height * scale) / 2
+			};
+		}
+		case "crop": {
+			const side = Math.min(to.width, to.height) * (options.cropFraction ?? 1);
+			const scaleX = from.width / side;
+			const scaleY = from.height / side;
+			return {
+				scaleX,
+				scaleY,
+				offsetX: -(to.width - side) / 2 * scaleX,
+				offsetY: -(to.height - side) / 2 * scaleY
+			};
+		}
+	}
+}
+/** Maps a point from model-input coordinates to original-image coordinates. */
+function scalePoint(point, options) {
+	const { scaleX, scaleY, offsetX, offsetY } = resizeTransform(options);
+	return {
+		x: (point.x - offsetX) / scaleX,
+		y: (point.y - offsetY) / scaleY
+	};
+}
+//#endregion
+//#region src/zoo/tasks/cv/utils/imagePreprocessor.ts
+/** CPU image preprocessor: any ImageBuffer in, the model's RGB CHW f32 input
+*  out. Resizes (stretch / letterbox / crop), converts the pixel format,
+*  moves channels first and normalizes, all in one pass over the output. */
+/** Index of the R, G and B byte inside one pixel of each format. */
+const RGB_INDEX = {
+	rgb: [
+		0,
+		1,
+		2
+	],
+	rgba: [
+		0,
+		1,
+		2
+	],
+	bgr: [
+		2,
+		1,
+		0
+	],
+	bgra: [
+		2,
+		1,
+		0
+	],
+	gray: [
+		0,
+		0,
+		0
+	]
+};
+function perChannel(v, name) {
+	if (typeof v === "number") return [
+		v,
+		v,
+		v
+	];
+	if (v.length !== 3) throw new RunntimeError("INVALID_ARGUMENT", `normalize.${name}: expected 3 values, got ${v.length}`);
+	return [
+		v[0],
+		v[1],
+		v[2]
+	];
+}
+function buildAxis$1(outLen, srcLen, scale, offset, interpolation) {
+	const i0 = new Int32Array(outLen);
+	const i1 = new Int32Array(outLen);
+	const w = new Float32Array(outLen);
+	const inside = new Uint8Array(outLen);
+	for (let d = 0; d < outLen; d++) {
+		const s = (d + .5 - offset) / scale;
+		if (s < 0 || s >= srcLen) continue;
+		inside[d] = 1;
+		if (interpolation === "nearest") {
+			i0[d] = i1[d] = Math.min(srcLen - 1, Math.floor(s));
+			continue;
+		}
+		const f = s - .5;
+		const a = Math.floor(f);
+		i0[d] = Math.max(0, a);
+		i1[d] = Math.min(srcLen - 1, a + 1);
+		w[d] = a < 0 ? 0 : f - a;
+	}
+	return {
+		i0,
+		i1,
+		w,
+		inside
+	};
+}
+function createImagePreprocessor(options, size) {
+	const { width, height, resizeMode } = {
+		...size,
+		resizeMode: options.resizeMode
+	};
+	checkImageSize(width, height, "input size");
+	const interpolation = options.interpolation ?? "linear";
+	const cropFraction = options.cropFraction ?? 1;
+	if (!(cropFraction > 0 && cropFraction <= 1)) throw new RunntimeError("INVALID_ARGUMENT", `cropFraction: expected a number in (0, 1], got ${cropFraction}`);
+	const padValue = options.padValue ?? 114;
+	const alpha = perChannel(options.normalizeOpts?.alpha ?? 1 / 255, "alpha");
+	const beta = perChannel(options.normalizeOpts?.beta ?? 0, "beta");
+	const hw = width * height;
+	const pad = [
+		padValue * alpha[0] + beta[0],
+		padValue * alpha[1] + beta[1],
+		padValue * alpha[2] + beta[2]
+	];
+	const scaleOptions = (input) => ({
+		from: {
+			width,
+			height
+		},
+		to: {
+			width: input.width,
+			height: input.height
+		},
+		resizeMode,
+		cropFraction
+	});
+	const process = (input, out) => {
+		out ??= new Float32Array(3 * hw);
+		if (out.length !== 3 * hw) throw new RunntimeError("INVALID_ARGUMENT", `out: ${out.length} floats, expected ${3 * hw}`);
+		checkImageBuffer(input);
+		const ch = FORMAT_CHANNELS[input.format];
+		const { data } = input;
+		const [ri, gi, bi] = RGB_INDEX[input.format];
+		const [ar, ag, ab] = alpha;
+		const [br, bg, bb] = beta;
+		const t = resizeTransform(scaleOptions(input));
+		if (t.scaleX === 1 && t.scaleY === 1 && t.offsetX === 0 && t.offsetY === 0) {
+			for (let i = 0; i < hw; i++) {
+				const p = i * ch;
+				out[i] = data[p + ri] * ar + br;
+				out[hw + i] = data[p + gi] * ag + bg;
+				out[2 * hw + i] = data[p + bi] * ab + bb;
+			}
+			return out;
+		}
+		const xs = buildAxis$1(width, input.width, t.scaleX, t.offsetX, interpolation);
+		const ys = buildAxis$1(height, input.height, t.scaleY, t.offsetY, interpolation);
+		const [padR, padG, padB] = pad;
+		const rowStride = input.width * ch;
+		for (let y = 0; y < height; y++) {
+			const rowIn = ys.inside[y];
+			const r0 = ys.i0[y] * rowStride;
+			const r1 = ys.i1[y] * rowStride;
+			const wy = ys.w[y];
+			for (let x = 0; x < width; x++) {
+				const o = y * width + x;
+				if (!rowIn || !xs.inside[x]) {
+					out[o] = padR;
+					out[hw + o] = padG;
+					out[2 * hw + o] = padB;
+					continue;
+				}
+				const c0 = xs.i0[x] * ch;
+				const c1 = xs.i1[x] * ch;
+				const wx = xs.w[x];
+				const w00 = (1 - wy) * (1 - wx);
+				const w01 = (1 - wy) * wx;
+				const w10 = wy * (1 - wx);
+				const w11 = wy * wx;
+				const r = data[r0 + c0 + ri] * w00 + data[r0 + c1 + ri] * w01 + data[r1 + c0 + ri] * w10 + data[r1 + c1 + ri] * w11;
+				const g = data[r0 + c0 + gi] * w00 + data[r0 + c1 + gi] * w01 + data[r1 + c0 + gi] * w10 + data[r1 + c1 + gi] * w11;
+				const b = data[r0 + c0 + bi] * w00 + data[r0 + c1 + bi] * w01 + data[r1 + c0 + bi] * w10 + data[r1 + c1 + bi] * w11;
+				out[o] = r * ar + br;
+				out[hw + o] = g * ag + bg;
+				out[2 * hw + o] = b * ab + bb;
+			}
+		}
+		return out;
+	};
+	return {
+		width,
+		height,
+		process,
+		scaleOptions,
+		gpuArgs: {
+			mode: resizeMode,
+			cropFraction,
+			outW: width,
+			outH: height,
+			alpha,
+			beta,
+			pad
+		}
+	};
+}
+//#endregion
+//#region src/zoo/tasks/cv/utils/resizeBicubic.ts
+/** Antialiased bicubic resize on the CPU. Downscaling widens the kernel by
+*  the scale, so every source pixel counts and fine detail does not
+*  alias. */
+/** The a of Keys' cubic convolution kernel. */
+const CUBIC_A = -.5;
+function cubic(x) {
+	const t = Math.abs(x);
+	if (t < 1) return (1.5 * t - 2.5) * t * t + 1;
+	if (t < 2) return (((t - 5) * t + 8) * t - 4) * CUBIC_A;
+	return 0;
+}
+function buildAxis(outLen, srcLen) {
+	const scale = srcLen / outLen;
+	const support = 2 * Math.max(scale, 1);
+	const inv = 1 / Math.max(scale, 1);
+	const taps = Math.ceil(support) * 2 + 1;
+	const start = new Int32Array(outLen);
+	const count = new Int32Array(outLen);
+	const weights = new Float32Array(outLen * taps);
+	for (let i = 0; i < outLen; i++) {
+		const center = scale * (i + .5);
+		const lo = Math.max(Math.trunc(center - support + .5), 0);
+		const n = Math.min(Math.trunc(center + support + .5), srcLen) - lo;
+		let total = 0;
+		for (let j = 0; j < n; j++) {
+			const w = cubic((j + lo - center + .5) * inv);
+			weights[i * taps + j] = w;
+			total += w;
+		}
+		if (total !== 0) for (let j = 0; j < n; j++) weights[i * taps + j] /= total;
+		start[i] = lo;
+		count[i] = n;
+	}
+	return {
+		start,
+		count,
+		weights,
+		taps
+	};
+}
+/** `image` resized to width × height: RGB [3, height, width] of whole
+*  values in 0..255. Width resizes first, then height, rounded to bytes in
+*  between. Throws INVALID_ARGUMENT for a bad size or byte count. */
+function resizeBicubic(image, width, height) {
+	checkImageSize(width, height, "resize");
+	checkImageBuffer(image);
+	const ch = FORMAT_CHANNELS[image.format];
+	const { data } = image;
+	const rgb = RGB_INDEX[image.format];
+	const srcW = image.width;
+	const srcH = image.height;
+	const xs = buildAxis(width, srcW);
+	const ys = buildAxis(height, srcH);
+	const plane = srcH * width;
+	const tmp = new Uint8ClampedArray(3 * plane);
+	const [ri, gi, bi] = rgb;
+	for (let y = 0; y < srcH; y++) for (let x = 0; x < width; x++) {
+		const n = xs.count[x];
+		const w0 = x * xs.taps;
+		let p = (y * srcW + xs.start[x]) * ch;
+		let r = 0;
+		let g = 0;
+		let b = 0;
+		for (let j = 0; j < n; j++, p += ch) {
+			const w = xs.weights[w0 + j];
+			r += data[p + ri] * w;
+			g += data[p + gi] * w;
+			b += data[p + bi] * w;
+		}
+		const o = y * width + x;
+		tmp[o] = r;
+		tmp[plane + o] = g;
+		tmp[2 * plane + o] = b;
+	}
+	const out = new Float32Array(3 * height * width);
+	const acc = new Float64Array(width);
+	for (let c = 0; c < 3; c++) for (let y = 0; y < height; y++) {
+		acc.fill(0);
+		const w0 = y * ys.taps;
+		for (let j = 0; j < ys.count[y]; j++) {
+			const w = ys.weights[w0 + j];
+			const src = (c * srcH + ys.start[y] + j) * width;
+			for (let x = 0; x < width; x++) acc[x] += tmp[src + x] * w;
+		}
+		const dst = (c * height + y) * width;
+		for (let x = 0; x < width; x++) out[dst + x] = Math.min(255, Math.max(0, Math.round(acc[x])));
+	}
+	return out;
+}
+//#endregion
+//#region src/zoo/embeddinggemma2/visionEncoder.ts
+/** EmbeddingGemma 2 image encoding: an image in, its token rows for the
+*  text model out, one eager forward of the vision tower per image. */
+/** Patch grid [cols, rows] of the largest resize, aspect ratio kept, that
+*  fits `maxTokens` image tokens with each side a multiple of pool ·
+*  patch pixels. Throws INVALID_ARGUMENT unless the size is positive. */
+function patchGrid(width, height, maxTokens, patch, pool) {
+	checkImageSize(width, height);
+	const maxPatches = maxTokens * pool * pool;
+	const factor = Math.sqrt(maxPatches * patch * patch / (width * height));
+	const side = pool * patch;
+	let w = Math.floor(factor * width / side) * side;
+	let h = Math.floor(factor * height / side) * side;
+	const maxSide = maxTokens * side;
+	if (h === 0) {
+		h = side;
+		w = Math.min(Math.floor(width / height) * side, maxSide);
+	} else if (w === 0) {
+		w = side;
+		h = Math.min(Math.floor(height / width) * side, maxSide);
+	}
+	return [w / patch, h / patch];
+}
+/** Pixels [cols · rows, 3·patch²] in [-1, 1], patches in row-major order,
+*  each patch's pixels in (row, column, channel) order. */
+function patchPixels(image, cols, rows, patch) {
+	const width = cols * patch;
+	const height = rows * patch;
+	const chw = resizeBicubic(image, width, height);
+	const scaled = (v) => v * 2 / 255 - 1;
+	const plane = width * height;
+	const out = new Float32Array(3 * plane);
+	let o = 0;
+	for (let py = 0; py < rows; py++) for (let px = 0; px < cols; px++) for (let y = py * patch; y < (py + 1) * patch; y++) for (let x = px * patch; x < (px + 1) * patch; x++) {
+		const i = y * width + x;
+		out[o++] = scaled(chw[i]);
+		out[o++] = scaled(chw[plane + i]);
+		out[o++] = scaled(chw[2 * plane + i]);
+	}
+	return out;
+}
+/** Pooling weights [N, P]: each image token averages its pool×pool square
+*  of patches. Tokens are in row-major order over the squares. */
+function poolWeights(cols, rows, pool) {
+	const tokenCols = cols / pool;
+	const n = tokenCols * (rows / pool);
+	const out = new Float32Array(n * cols * rows);
+	for (let k = 0; k < cols * rows; k++) {
+		const token = Math.floor(k % cols / pool) + tokenCols * Math.floor(Math.floor(k / cols) / pool);
+		out[token * cols * rows + k] = 1 / (pool * pool);
+	}
+	return out;
+}
+/** An image to its token rows [N · text hidden], N at most `maxTokens`.
+*  Runs on `ex` and trims its pool after. Throws INVALID_ARGUMENT for a
+*  malformed image. */
+async function encodeImage(model, image, maxTokens, ex) {
+	const { patch, pool, headDim, ropeTheta } = model.cfg;
+	const [cols, rows] = patchGrid(image.width, image.height, maxTokens, patch, pool);
+	const p = cols * rows;
+	const act = model.input_proj.weight.shape.dtype === "f16" ? "f16" : "f32";
+	const upload = (data, r, dtype) => tensor(data, {
+		elems: data.length,
+		dtype,
+		dims: [r, data.length / r]
+	});
+	const xs = new Float32Array(p);
+	const ys = new Float32Array(p);
+	for (let k = 0; k < p; k++) {
+		xs[k] = k % cols;
+		ys[k] = Math.floor(k / cols);
+	}
+	const { cos, sin } = visionRopeTables(cols, rows, headDim, ropeTheta);
+	const inputs = {
+		patches: upload(patchPixels(image, cols, rows, patch), p, act),
+		xs: upload(xs, p, "f32"),
+		ys: upload(ys, p, "f32"),
+		cos: upload(cos, p, "f32"),
+		sin: upload(sin, p, "f32"),
+		pool: upload(poolWeights(cols, rows, pool), p / (pool * pool), act)
 	};
+	try {
+		return await toArray(model.forward(inputs), ex);
+	} finally {
+		for (const v of Object.values(inputs)) v.buffer.destroy();
+		ex.trim();
+	}
 }
-const MAX_WORD_CHARS = 100;
-const isWhitespace = (ch) => ch === " " || ch === "	" || ch === "\n" || ch === "\r" || /\p{Zs}/u.test(ch);
-const isControl = (ch) => ch !== "	" && ch !== "\n" && ch !== "\r" && /\p{C}/u.test(ch);
-const isPunctuation = (ch) => {
-	const c = ch.codePointAt(0);
-	if (c >= 33 && c <= 47 || c >= 58 && c <= 64 || c >= 91 && c <= 96 || c >= 123 && c <= 126) return true;
-	return /\p{P}/u.test(ch);
+//#endregion
+//#region src/zoo/embeddinggemma2/visionModel.ts
+/** EmbeddingGemma 2 vision tower: a bidirectional ViT over an image's 16×16
+*  patches, each 3×3 square of patches averaged into one image token and
+*  projected to the text model's width.
+*
+*  Layers are the text model's without PLE. Positions enter twice: x and y
+*  embeddings on the patches and a 2D rope on q and k. q, k and v are
+*  RMS-normed per head, so scores carry no 1/√d scale. */
+/** Patch count from which attention runs on matmuls. */
+const MATMUL_ATTENTION_MIN_PATCHES = 2560;
+/** Most scores one matmul writes: 128 MiB of f32, WebGPU's default
+*  storage binding limit. Larger images split their queries into equal
+*  chunks. */
+const MAX_SCORES = 2 ** 25;
+var VisionLayer = class extends Module {
+	cfg;
+	input_layernorm;
+	/** q | k | v rows, with q and k permuted for the interleaved rope. */
+	qkv;
+	/** q_norm and k_norm tiled per head, ones for v. */
+	qkv_norm;
+	o_proj;
+	post_attention_layernorm;
+	pre_feedforward_layernorm;
+	gate_proj;
+	up_proj;
+	down_proj;
+	post_feedforward_layernorm;
+	constructor(cfg) {
+		super();
+		this.cfg = cfg;
+		const { hidden, heads, headDim, ffn, eps } = cfg;
+		const width = 3 * heads * headDim;
+		const norm = () => new RMSNorm(hidden, eps);
+		this.input_layernorm = norm();
+		this.qkv = new Linear(hidden, width, { bias: false });
+		this.qkv_norm = new Parameter({
+			elems: width,
+			dtype: "f32",
+			dims: [width]
+		});
+		this.o_proj = new Linear(heads * headDim, hidden, { bias: false });
+		this.post_attention_layernorm = norm();
+		this.pre_feedforward_layernorm = norm();
+		this.gate_proj = new Linear(hidden, ffn, {
+			bias: false,
+			activation: "geluTanh"
+		});
+		this.up_proj = new Linear(hidden, ffn, { bias: false });
+		this.down_proj = new Linear(ffn, hidden, { bias: false });
+		this.post_feedforward_layernorm = norm();
+	}
+	forward(x, inp) {
+		const { hidden, heads, headDim: d, eps } = this.cfg;
+		const w = heads * d;
+		const postNorm = (norm, y, residual) => rmsNorm(y, norm.scale.value, norm.eps, { residual });
+		const qkv = this.qkv.forward(this.input_layernorm.forward(x));
+		const n = rmsNorm(qkv, this.qkv_norm.value, eps, { group: d });
+		const qk = rope(n, inp.cos, inp.sin, {
+			headDim: d,
+			width: 2 * w
+		});
+		const head = (v, start) => slice(v, 1, start, start + d);
+		const p = x.shape.elems / hidden;
+		let a;
+		if (p >= MATMUL_ATTENTION_MIN_PATCHES) {
+			const kv = Array.from({ length: heads }, (_, h) => ({
+				kT: transpose(head(qk, w + h * d)),
+				v: head(n, 2 * w + h * d)
+			}));
+			const parts = Math.ceil(p * p / MAX_SCORES);
+			const step = Math.ceil(p / parts);
+			const chunks = [];
+			for (let r = 0; r < p; r += step) {
+				const q = slice(qk, 0, r, Math.min(r + step, p));
+				const outs = kv.map(({ kT, v }, h) => matmul(softmax(matmul(head(q, h * d), kT)), v));
+				chunks.push(cat(outs, 1));
+			}
+			a = cat(chunks, 0);
+		} else a = sdpa(slice(qk, 1, 0, w), slice(qk, 1, w, 2 * w), slice(n, 1, 2 * w, 3 * w), {
+			qHeads: heads,
+			kvHeads: heads,
+			headDim: d,
+			windowLeft: Infinity,
+			windowRight: Infinity
+		});
+		x = postNorm(this.post_attention_layernorm, this.o_proj.forward(a), x);
+		const f = this.pre_feedforward_layernorm.forward(x);
+		const m = this.down_proj.forward(mul(this.gate_proj.forward(f), this.up_proj.forward(f)));
+		return postNorm(this.post_feedforward_layernorm, m, x);
+	}
+};
+var EmbeddingGemma2VisionModel = class extends Module {
+	cfg;
+	input_proj;
+	pos_x;
+	pos_y;
+	layers;
+	/** The pooled tokens enter this weightless norm scaled by √hidden. The
+	*  norm cancels the scale, so eps divided by hidden stands in for it. */
+	embedding_pre_projection_norm;
+	embedding_projection;
+	constructor(cfg = EMBEDDINGGEMMA2_VISION) {
+		super();
+		this.cfg = cfg;
+		const { hidden, patch, positions, eps } = cfg;
+		this.input_proj = new Linear(3 * patch * patch, hidden, { bias: false });
+		this.pos_x = new Embedding(positions, hidden);
+		this.pos_y = new Embedding(positions, hidden);
+		this.layers = new ModuleList(Array.from({ length: cfg.layers }, () => new VisionLayer(cfg)));
+		this.embedding_pre_projection_norm = new RMSNorm(hidden, eps / hidden);
+		this.embedding_projection = new Linear(hidden, EMBEDDINGGEMMA2_TEXT.hidden, { bias: false });
+	}
+	/** One image to its tokens [N, text hidden], ready to stand in for N
+	*  placeholder rows of the text model's input. */
+	forward(inp) {
+		const addend = add(this.pos_x.forward(inp.xs), this.pos_y.forward(inp.ys));
+		let x = this.input_proj.forward(inp.patches, { addend });
+		for (const layer of this.layers.items) x = layer.forward(x, inp);
+		const pooled = matmul(inp.pool, x);
+		return this.embedding_projection.forward(this.embedding_pre_projection_norm.forward(pooled));
+	}
+	transformStateDict(sd, prefix) {
+		transformEmbeddingGemma2VisionStateDict(sd, prefix, this.cfg);
+	}
 };
-const isCjkIdeograph = (c) => c >= 19968 && c <= 40959 || c >= 13312 && c <= 19903 || c >= 131072 && c <= 173791 || c >= 173824 && c <= 177983 || c >= 177984 && c <= 178207 || c >= 178208 && c <= 183983 || c >= 63744 && c <= 64255 || c >= 194560 && c <= 195103;
-function basicTokenize(text, doLowerCase) {
-	let cleaned = "";
-	for (const ch of text) {
-		const c = ch.codePointAt(0);
-		if (c === 0 || c === 65533 || isControl(ch)) continue;
-		if (isCjkIdeograph(c)) cleaned += ` ${ch} `;
-		else cleaned += isWhitespace(ch) ? " " : ch;
-	}
-	const words = [];
-	for (const token of cleaned.split(" ")) {
-		if (!token) continue;
-		let t = token;
-		if (doLowerCase) t = t.toLowerCase().normalize("NFD").replace(/\p{Mn}/gu, "");
-		let current = "";
-		for (const ch of t) if (isPunctuation(ch)) {
-			if (current) words.push(current);
-			words.push(ch);
-			current = "";
-		} else current += ch;
-		if (current) words.push(current);
-	}
-	return words;
-}
-function createMinilmTokenizer(asset) {
-	if (asset.version !== 1) throw new Error(`minilm tokenizer: unsupported asset version ${asset.version}`);
-	const tokenToId = /* @__PURE__ */ new Map();
-	asset.vocab.forEach((token, id) => tokenToId.set(token, id));
-	const wordpiece = (word, out) => {
-		const chars = [...word];
-		if (chars.length > MAX_WORD_CHARS) {
-			out.push(asset.unkId);
-			return;
+//#endregion
+//#region src/zoo/embeddinggemma2/embeddingModel.ts
+/** EmbeddingGemma 2 for createEmbedder: text, images, video and audio,
+*  task instructions, 768 values or fewer with `dims`. */
+async function createEmbeddingModel$1(load) {
+	const { maxTokens = EMBEDDINGGEMMA2_MAX_TOKENS, imageTokens = 280 } = load;
+	if (!Number.isInteger(maxTokens) || maxTokens < 2 || maxTokens > 2048) throw new RunntimeError("INVALID_ARGUMENT", `createEmbedder: maxTokens must be an integer from 2 to ${EMBEDDINGGEMMA2_MAX_TOKENS}, got ${maxTokens}`);
+	const budgets = IMAGE_TOKEN_BUDGETS;
+	if (!budgets.includes(imageTokens)) throw new RunntimeError("INVALID_ARGUMENT", `createEmbedder: imageTokens must be one of ${budgets.join(", ")}, got ${imageTokens}`);
+	const tokenizer = createEmbeddingGemma2Tokenizer(load.tokenizer);
+	const scope = createResourceScope();
+	try {
+		const model = scope.track(new EmbeddingGemma2Model());
+		const vision = load.vision && scope.track(new EmbeddingGemma2VisionModel());
+		const audio = load.audio && scope.track(new EmbeddingGemma2AudioModel());
+		const visionEx = scope.track(gpuExecutor(defaultRoot()));
+		const audioEx = scope.track(gpuExecutor(defaultRoot()));
+		if (load.dtype === "f16") {
+			model.half();
+			vision?.half();
+			audio?.half();
 		}
-		const pieces = [];
-		let start = 0;
-		while (start < chars.length) {
-			let end = chars.length;
-			let id;
-			while (end > start) {
-				const piece = (start > 0 ? "##" : "") + chars.slice(start, end).join("");
-				id = tokenToId.get(piece);
-				if (id !== void 0) break;
-				end--;
+		const progress = /* @__PURE__ */ new Map();
+		const track = (file) => (name, done, total) => {
+			progress.set(file, [done, total]);
+			let d = 0;
+			let t = 0;
+			for (const [fd, ft] of progress.values()) {
+				d += fd;
+				t += ft;
+			}
+			load.onProgress?.(name, d, t);
+		};
+		const loads = [model.loadStateDict(load.text, { onProgress: track("text") })];
+		if (vision && load.vision) loads.push(vision.loadStateDict(load.vision, { onProgress: track("vision") }));
+		if (audio && load.audio) loads.push(audio.loadStateDict(load.audio, { onProgress: track("audio") }));
+		await Promise.all(loads);
+		const core = scope.track(createEmbeddingGemma2EmbedCore(model));
+		const { bosId, eosId, padId, boiId, eoiId, boaId, eoaId } = tokenizer;
+		const { patch, pool } = EMBEDDINGGEMMA2_VISION;
+		/** An input as token ids and media rows: <bos>, the instruction and the
+		*  parts in order, <eos>. Text next to other text joins it, each image
+		*  or video frame is <|image> rows <image|>, and each clip <|audio> rows
+		*  <audio|>. The length is checked before any tower runs. */
+		const toInput = async (where, input, task) => {
+			const parts = Array.isArray(input) ? input : [input];
+			const ids = [bosId];
+			const pending = [];
+			let text = task === void 0 ? "" : EMBEDDINGGEMMA2_PROMPTS[task];
+			const flush = () => {
+				ids.push(...tokenizer.encode(text));
+				text = "";
+			};
+			const addMedia = (begin, tokens, end, encode) => {
+				flush();
+				ids.push(begin);
+				pending.push({
+					at: ids.length,
+					encode
+				});
+				for (let i = 0; i < tokens; i++) ids.push(padId);
+				ids.push(end);
+			};
+			const addImage = (image, budget) => {
+				const [cols, rows] = patchGrid(image.width, image.height, budget, patch, pool);
+				addMedia(boiId, cols * rows / (pool * pool), eoiId, () => {
+					if (!vision) throw new RunntimeError("INVALID_ARGUMENT", `${where}: images and video need the vision tower, which this embedder did not load`);
+					return encodeImage(vision, image, budget, visionEx);
+				});
+			};
+			for (const part of parts) if (typeof part === "string") text += part;
+			else if ("image" in part) addImage(part.image, imageTokens);
+			else if ("video" in part) for (const frame of part.video) addImage(frame, 140);
+			else {
+				const samples = part.audio;
+				addMedia(boaId, audioTokens(samples.length), eoaId, () => {
+					if (!audio) throw new RunntimeError("INVALID_ARGUMENT", `${where}: audio needs the audio tower, which this embedder did not load`);
+					return encodeAudio(audio, samples, audioEx);
+				});
 			}
-			if (id === void 0) {
-				out.push(asset.unkId);
-				return;
+			flush();
+			ids.push(eosId);
+			if (ids.length > maxTokens) {
+				if (pending.length === 0) return {
+					ids: [...ids.slice(0, maxTokens - 1), eosId],
+					media: []
+				};
+				throw new RunntimeError("INVALID_ARGUMENT", `${where}: the input takes ${ids.length} tokens, more than maxTokens ${maxTokens}`);
 			}
-			pieces.push(id);
-			start = end;
-		}
-		out.push(...pieces);
+			const media = [];
+			for (const { at, encode } of pending) media.push({
+				at,
+				rows: await encode()
+			});
+			return {
+				ids,
+				media
+			};
+		};
+		return {
+			dim: EMBEDDING_DIM,
+			dims: EMBEDDING_DIMS,
+			media: true,
+			async warm() {
+				const probe = await toInput("createEmbedder", "", void 0);
+				await core.embedPooledBatch([probe, probe]);
+				await core.warmBuckets(probe);
+				if (vision) {
+					const dot = imageBuffer(/* @__PURE__ */ new Uint8Array(4), 1, 1);
+					await encodeImage(vision, dot, imageTokens, visionEx);
+					if (imageTokens !== 140) await encodeImage(vision, dot, 140, visionEx);
+				}
+				if (audio) await encodeAudio(audio, /* @__PURE__ */ new Float32Array(1600), audioEx);
+				return core.embedPooled(probe);
+			},
+			async pool(where, inputs, task) {
+				const prepared = [];
+				for (const input of inputs) prepared.push(await toInput(where, input, task));
+				return prepared.length === 1 ? core.embedPooled(prepared[0]) : core.embedPooledBatch(prepared);
+			},
+			dispose: () => scope.dispose()
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+const isWordPieceTokenizerJson = (json) => typeof json === "object" && json !== null && "model" in json && typeof json.model === "object" && json.model !== null && "type" in json.model && json.model.type === "WordPiece";
+/** Builds the tokenizer from a Hugging Face tokenizer.json of the WordPiece
+*  kind. Throws CHECKPOINT_MISMATCH for any other file. */
+function createMinilmTokenizer(json, maxTokens = 256) {
+	const bad = (why) => checkpointMismatch("minilm tokenizer", why);
+	if (!isWordPieceTokenizerJson(json)) throw bad("expected a WordPiece tokenizer.json");
+	const tokenizer = new Tokenizer(json, {});
+	const idOf = (token) => {
+		const id = tokenizer.token_to_id(token);
+		if (id === void 0) throw bad(`vocab has no ${token}`);
+		return id;
 	};
+	const clsId = idOf("[CLS]");
+	const sepId = idOf("[SEP]");
 	return {
-		clsId: asset.clsId,
-		sepId: asset.sepId,
+		clsId,
+		sepId,
 		encode(text) {
-			const pieces = [];
-			for (const word of basicTokenize(text, asset.doLowerCase)) wordpiece(word, pieces);
-			const body = pieces.slice(0, asset.maxWordpieces - 2);
+			const pieces = tokenizer.encode(text, { add_special_tokens: false }).ids;
 			return [
-				asset.clsId,
-				...body,
-				asset.sepId
+				clsId,
+				...pieces.slice(0, maxTokens - 2),
+				sepId
 			];
 		}
 	};
 }
 //#endregion
-//#region src/zoo/tasks/nlp/textEmbedding.ts
-/** Text embedding task: text in, one unit-length vector out. Runs
-*  all-MiniLM-L6-v2 on the initRunntime() device. */
-/** Dot product of two unit-length embeddings, which is their cosine
-*  similarity: 1 for the same meaning, near 0 for unrelated text. */
+//#region src/zoo/minilm/embeddingModel.ts
+/** all-MiniLM-L6-v2 for createEmbedder: English text only, no instructions,
+*  384 values. */
+async function createEmbeddingModel(load) {
+	const { maxTokens } = load;
+	const most = MINILM_L6.maxPositions;
+	if (maxTokens !== void 0 && (!Number.isInteger(maxTokens) || maxTokens < 2 || maxTokens > most)) throw new RunntimeError("INVALID_ARGUMENT", `createEmbedder: maxTokens must be an integer from 2 to ${most}, got ${maxTokens}`);
+	const tokenizer = createMinilmTokenizer(load.tokenizer, maxTokens);
+	const scope = createResourceScope();
+	try {
+		const model = scope.track(new MinilmModel(MINILM_L6));
+		if (load.dtype === "f16") model.half();
+		await model.loadStateDict(load.text, { onProgress: load.onProgress });
+		const core = scope.track(createMinilmEmbedCore(model));
+		const pair = [tokenizer.clsId, tokenizer.sepId];
+		return {
+			dim: EMBEDDING_DIM$1,
+			dims: [EMBEDDING_DIM$1],
+			media: false,
+			async warm() {
+				await core.embedPooledBatch([pair, pair]);
+				await core.warmBuckets(pair);
+				return core.embedPooled(pair);
+			},
+			pool(_where, inputs) {
+				const ids = inputs.map((input) => tokenizer.encode(typeof input === "string" ? input : input.join("")));
+				return ids.length === 1 ? core.embedPooled(ids[0]) : core.embedPooledBatch(ids);
+			},
+			dispose: () => scope.dispose()
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+//#endregion
+//#region src/zoo/tasks/multimodal/embedding.ts
+/** Embedding task: text, images, video and audio in, one unit-length vector
+*  out, all in one space. Runs EmbeddingGemma 2 or all-MiniLM-L6-v2 on the
+*  initRunntime() device. */
+/** Cosine similarity of two unit-length vectors: 1 for the same meaning,
+*  near 0 for unrelated inputs. */
 function similarity(a, b) {
 	let dot = 0;
 	for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
 	return dot;
 }
+/** Scales `v` to unit length in place and returns it. */
 const normalize = (v) => {
 	let sumSq = 0;
 	for (const x of v) sumSq += x * x;
@@ -189,55 +2001,111 @@ const normalize = (v) => {
 	for (let i = 0; i < v.length; i++) v[i] *= inv;
 	return v;
 };
-/** Loads the checkpoint and the tokenizer, warms every GPU path once, and
-*  returns the runner. With no config, loads all-MiniLM-L6-v2 from the
-*  Hugging Face Hub. */
-async function createTextEmbedder(config = {}, opts = {}) {
+const isImagePart = (part) => typeof part === "object" && part !== null && "image" in part;
+const isVideoPart = (part) => typeof part === "object" && part !== null && "video" in part && Array.isArray(part.video);
+const isAudioPart = (part) => typeof part === "object" && part !== null && "audio" in part && part.audio instanceof Float32Array;
+/** One cache key per file, using the whole path so same-named files of two
+*  precisions stay apart. Bump the version to invalidate. */
+const cacheId = (path) => typeof path === "string" ? `embedding-v1/${path.replace(/^https?:\/\//, "")}` : void 0;
+/** Loads the model in `modelPath` with its tokenizer and towers, warms the
+*  GPU, and returns the runner. With no config, loads EmbeddingGemma 2 from
+*  the Hugging Face Hub. */
+async function createEmbedder(config = {}, opts = {}) {
 	const scope = createResourceScope();
 	try {
 		const device = defaultRoot().device;
-		const { modelPath = models.textEmbedding.ALL_MINILM_L6_V2.DEFAULT.modelPath, tokenizerPath = models.textEmbedding.ALL_MINILM_L6_V2.DEFAULT.tokenizerPath, dtype = supportsF16() ? "f16" : "f32", maxTokens } = config;
-		const cacheId = (path) => typeof path === "string" ? `minilm-v1/${path.replace(/^https?:\/\//, "")}` : void 0;
-		const sd = await openWeights(modelPath, {
+		const modelPath = config.modelPath ?? models.embedding.EMBEDDINGGEMMA_2.DEFAULT.modelPath;
+		const text = await openWeights(modelPath, {
 			...opts,
 			cacheId: opts.cacheId ?? cacheId(modelPath)
 		});
-		const tokenizer = createMinilmTokenizer(minilmTokenizerAsset(await fetchJson(tokenizerPath, {
+		const minilm = text.tensors.has("embeddings.word_embeddings.weight");
+		const defaults = minilm ? {
+			...models.embedding.ALL_MINILM_L6_V2.DEFAULT,
+			visionPath: null,
+			audioPath: null
+		} : models.embedding.EMBEDDINGGEMMA_2.DEFAULT;
+		const { visionPath = defaults.visionPath, audioPath = defaults.audioPath, tokenizerPath = defaults.tokenizerPath, dtype = supportsF16() ? "f16" : "f32", maxTokens, imageTokens } = config;
+		if (minilm && (visionPath !== null || audioPath !== null)) throw new RunntimeError("INVALID_ARGUMENT", "createEmbedder: all-MiniLM-L6-v2 has no vision or audio tower, set no visionPath or audioPath");
+		const open = (path) => path === null ? void 0 : openWeights(path, {
+			...opts,
+			cacheId: cacheId(path)
+		});
+		const vision = await open(visionPath);
+		const audio = await open(audioPath);
+		const tokenizer = await fetchJson(tokenizerPath, {
 			...opts,
 			cacheId: cacheId(tokenizerPath)
-		}), maxTokens));
+		});
 		throwIfAborted(opts.signal);
-		const model = scope.track(new MinilmModel(MINILM_L6));
-		if (dtype === "f16") model.half();
-		await model.loadStateDict(sd, { onProgress: opts.onProgress });
-		const core = scope.track(createMinilmEmbedCore(model));
+		const make = minilm ? createEmbeddingModel : createEmbeddingModel$1;
+		const model = scope.track(await make({
+			text,
+			vision,
+			audio,
+			tokenizer,
+			dtype,
+			maxTokens,
+			imageTokens,
+			onProgress: opts.onProgress
+		}));
+		throwIfAborted(opts.signal);
+		await warmUp(device, () => model.warm());
 		let disposed = false;
 		const guard = () => {
-			if (disposed) throw new Error("text embedder is disposed");
+			if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "embedder is disposed");
 		};
-		const embedTokens = async (ids) => normalize(await core.embedPooled(ids));
-		const embedTokensBatch = async (idsList) => {
-			if (idsList.length === 0) return [];
-			if (idsList.length === 1) return [await embedTokens(idsList[0])];
-			const pooled = await core.embedPooledBatch(idsList);
-			return idsList.map((_, b) => normalize(pooled.slice(b * EMBEDDING_DIM, (b + 1) * EMBEDDING_DIM)));
+		/** Throws unless `input` is an EmbedInput this runner can embed. */
+		const check = (where, input) => {
+			const parts = Array.isArray(input) ? input : [input];
+			if (parts.length === 0) throw new RunntimeError("INVALID_ARGUMENT", `${where}: an input needs at least one part`);
+			for (const part of parts) {
+				if (typeof part === "string") continue;
+				if (!model.media) throw new RunntimeError("INVALID_ARGUMENT", `${where}: this model reads only text, a part must be a string`);
+				if (isAudioPart(part)) {
+					audioTokens(part.audio.length);
+					continue;
+				}
+				if (!isImagePart(part) && !(isVideoPart(part) && part.video.length > 0)) throw new RunntimeError("INVALID_ARGUMENT", `${where}: a part must be a string, { image }, { video } with at least one frame or { audio } as a Float32Array`);
+				if (isImagePart(part)) checkImageBuffer(part.image);
+				else for (const frame of part.video) checkImageBuffer(frame);
+			}
+		};
+		const checkTask = (where, task) => {
+			if (task !== void 0 && !Object.hasOwn(EMBEDDINGGEMMA2_PROMPTS, String(task))) throw new RunntimeError("INVALID_ARGUMENT", `${where}: task must be one of ${Object.keys(EMBEDDINGGEMMA2_PROMPTS).join(", ")}, got ${task}`);
+		};
+		const checkDims = (where, dims) => {
+			if (dims !== void 0 && (typeof dims !== "number" || !model.dims.includes(dims))) throw new RunntimeError("INVALID_ARGUMENT", `${where}: dims must be one of ${model.dims.join(", ")}, got ${dims}`);
+		};
+		/** Each input's vector: the first `dims` values of its pooled row, unit
+		*  length. */
+		const embedInputs = async (where, inputs, { task, dims = model.dim }) => {
+			if (inputs.length === 0) return [];
+			const pooled = await model.pool(where, inputs, task);
+			return inputs.map((_, b) => normalize(pooled.slice(b * model.dim, b * model.dim + dims)));
+		};
+		let queue = Promise.resolve();
+		const serial = (work) => {
+			const run = queue.then(work);
+			queue = run.catch(() => void 0);
+			return run.catch(rethrowRunError);
 		};
-		throwIfAborted(opts.signal);
-		await warmUp(device, async () => {
-			const pair = [tokenizer.clsId, tokenizer.sepId];
-			await embedTokensBatch([pair, pair]);
-			await core.warmBuckets(pair);
-			return embedTokens(pair);
-		});
 		return {
-			dim: EMBEDDING_DIM,
-			async embed(input) {
+			dim: model.dim,
+			async embed(input, embedOpts = {}) {
 				guard();
-				return embedTokens(tokenizer.encode(input));
+				check("embed", input);
+				checkTask("embed", embedOpts.task);
+				checkDims("embed", embedOpts.dims);
+				return serial(async () => (await embedInputs("embed", [input], embedOpts))[0]);
 			},
-			async embedBatch(inputs) {
+			async embedBatch(inputs, embedOpts = {}) {
 				guard();
-				return embedTokensBatch(inputs.map((t) => tokenizer.encode(t)));
+				if (!Array.isArray(inputs)) throw new RunntimeError("INVALID_ARGUMENT", "embedBatch: inputs must be an array");
+				for (const input of inputs) check("embedBatch", input);
+				checkTask("embedBatch", embedOpts.task);
+				checkDims("embedBatch", embedOpts.dims);
+				return serial(() => embedInputs("embedBatch", inputs, embedOpts));
 			},
 			dispose() {
 				disposed = true;
@@ -246,7 +2114,7 @@ async function createTextEmbedder(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 //#endregion
@@ -269,11 +2137,11 @@ async function createPrivacyFilter(config = {}, opts = {}) {
 		let queue = Promise.resolve();
 		return {
 			async detect(text) {
-				if (disposed) throw new Error("privacy filter is disposed");
-				if (typeof text !== "string") throw new Error("detect: text must be a string");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "privacy filter is disposed");
+				if (typeof text !== "string") throw new RunntimeError("INVALID_ARGUMENT", "detect: text must be a string");
 				const run = queue.then(() => detector.detect(text));
 				queue = run.catch(() => void 0);
-				return (await run).spans;
+				return (await run.catch(rethrowRunError)).spans;
 			},
 			dispose() {
 				disposed = true;
@@ -282,7 +2150,7 @@ async function createPrivacyFilter(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 //#endregion
@@ -319,6 +2187,28 @@ function analyzeSegment(audio, opts) {
 	};
 }
 //#endregion
+//#region src/zoo/moonshine/tokenizer.ts
+/** Moonshine tokenizer, decode-only: the decoder starts from BOS and emits
+*  ids, so id → text is the whole job. tokenizers.js runs the Hub's Llama-style
+*  BPE tokenizer.json with its special ids skipped and the text left as is. */
+const isBpeTokenizerJson = (json) => typeof json === "object" && json !== null && "model" in json && typeof json.model === "object" && json.model !== null && "type" in json.model && json.model.type === "BPE";
+/** Builds the tokenizer from a Hugging Face tokenizer.json of the BPE kind.
+*  Throws CHECKPOINT_MISMATCH for any other file. */
+function createMoonshineTokenizer(json) {
+	const bad = (why) => checkpointMismatch("moonshine tokenizer", why);
+	if (!isBpeTokenizerJson(json)) throw bad("expected a BPE tokenizer.json");
+	const tokenizer = new Tokenizer(json, {});
+	const eosId = tokenizer.token_to_id("</s>");
+	if (eosId === void 0) throw bad("vocab has no </s>");
+	return {
+		eosId,
+		decode: (ids) => tokenizer.decode(ids, {
+			skip_special_tokens: true,
+			clean_up_tokenization_spaces: false
+		})
+	};
+}
+//#endregion
 //#region src/zoo/moonshine-streaming/config.ts
 const windows = (layers) => Object.freeze(Array.from({ length: layers }, (_, i) => i < 2 || i >= layers - 2 ? [16, 4] : [16, 0]));
 const MOONSHINE_STREAMING_TINY = Object.freeze({
@@ -402,7 +2292,7 @@ function presetFromStateDict(sd) {
 		MOONSHINE_STREAMING_MEDIUM
 	];
 	for (const cfg of presets) if (cfg.dec.hidden === width) return cfg;
-	throw new Error(embedding === void 0 ? "moonshine-streaming weights: no token embedding, not a Moonshine checkpoint" : `moonshine-streaming weights: embedding width ${width} matches no known size`);
+	throw checkpointMismatch("moonshine-streaming weights", embedding === void 0 ? "no token embedding, not a Moonshine checkpoint" : `embedding width ${width} matches no known size`);
 }
 //#endregion
 //#region src/zoo/moonshine-streaming/frontend.ts
@@ -702,7 +2592,7 @@ const MAX_CHUNK_SECONDS = 30;
 const SPLIT_SEARCH_SECONDS = 5;
 async function createTranscriber(sd, tokenizer, opts = {}) {
 	const root = defaultRoot();
-	if (sd.metadata["model"] && sd.metadata["model"] !== "moonshine-streaming") throw new Error(`moonshine-streaming weights: file is for model '${sd.metadata["model"]}', expected 'moonshine-streaming'`);
+	if (sd.metadata["model"] && sd.metadata["model"] !== "moonshine-streaming") throw checkpointMismatch("moonshine-streaming weights", `file is for model '${sd.metadata["model"]}', expected 'moonshine-streaming'`);
 	const cfg = opts.cfg ?? presetFromStateDict(sd);
 	const dec = decoderView(cfg);
 	const perf = opts.perf;
@@ -736,14 +2626,14 @@ async function createTranscriber(sd, tokenizer, opts = {}) {
 	}));
 	const idsBuf = tensor(root, new Float32Array(DECODE_POSITIONS), [DECODE_POSITIONS, 1]);
 	const padToFrames = (audio) => {
-		if (audio.length === 0) throw new Error("transcribe: empty audio");
+		if (audio.length === 0) throw new RunntimeError("INVALID_ARGUMENT", "transcribe: empty audio");
 		const frames = Math.ceil(audio.length / cfg.frameLen);
 		if (frames * cfg.frameLen === audio.length) return audio;
 		const padded = new Float32Array(frames * cfg.frameLen);
 		padded.set(audio);
 		return padded;
 	};
-	const transcribeUtterance = async (rawAudio) => {
+	const transcribeUtterance = async (rawAudio, tokensPerSecond) => {
 		perf?.onPhase?.("encode");
 		const t0 = performance.now();
 		const audio = padToFrames(rawAudio);
@@ -754,7 +2644,7 @@ async function createTranscriber(sd, tokenizer, opts = {}) {
 		evalValues([adapterOut, ...cross.flatMap((c) => [c.k, c.v])], ex);
 		if (perf?.syncAfterEncode) await root.device.queue.onSubmittedWorkDone();
 		const encodeMs = performance.now() - t0;
-		const maxTokens = Math.min(DECODE_POSITIONS, Math.ceil(rawAudio.length / SAMPLE_RATE * TOKENS_PER_SECOND));
+		const maxTokens = Math.min(DECODE_POSITIONS, Math.ceil(rawAudio.length / SAMPLE_RATE * tokensPerSecond));
 		const release = (kvs) => {
 			for (const { k, v } of kvs) {
 				ex.releaseOutput(k.buffer, k.shape);
@@ -804,7 +2694,7 @@ async function createTranscriber(sd, tokenizer, opts = {}) {
 		release(cross);
 		return {
 			ids,
-			text: decodeTokens(tokenizer, ids),
+			text: tokenizer.decode(ids),
 			timings: {
 				encodeMs,
 				decodeMs: performance.now() - t1,
@@ -817,11 +2707,11 @@ async function createTranscriber(sd, tokenizer, opts = {}) {
 		searchSeconds: opts.chunking?.searchSeconds ?? SPLIT_SEARCH_SECONDS,
 		sampleRate: SAMPLE_RATE
 	};
-	const transcribeAll = async (audio) => {
+	const transcribeAll = async (audio, tokensPerSecond) => {
 		const chunks = splitIntoChunks(audio, chunkOpts);
-		if (chunks.length === 1) return transcribeUtterance(audio);
+		if (chunks.length === 1) return transcribeUtterance(audio, tokensPerSecond);
 		const results = [];
-		for (const chunk of chunks) results.push(await transcribeUtterance(chunk));
+		for (const chunk of chunks) results.push(await transcribeUtterance(chunk, tokensPerSecond));
 		return {
 			ids: results.flatMap((r) => r.ids),
 			text: results.map((r) => r.text.trim()).filter((t) => t.length > 0).join(" "),
@@ -848,56 +2738,20 @@ async function createTranscriber(sd, tokenizer, opts = {}) {
 	};
 	let inFlight = Promise.resolve();
 	let disposed = false;
-	const transcribe = (audio) => {
-		if (disposed) return Promise.reject(/* @__PURE__ */ new Error("transcriber is disposed"));
-		const job = inFlight.then(() => transcribeAll(audio));
+	const transcribe = (audio, tokensPerSecond = TOKENS_PER_SECOND) => {
+		if (disposed) return Promise.reject(new RunntimeError("RESOURCE_DISPOSED", "transcriber is disposed"));
+		const job = inFlight.then(() => transcribeAll(audio, tokensPerSecond));
 		inFlight = job.catch(() => void 0);
 		return job;
 	};
 	return {
 		minSamples: cfg.frameLen,
-		transcribe,
-		dispose: () => {
-			disposed = true;
-			dispose();
-		}
-	};
-}
-//#endregion
-//#region src/zoo/tasks/audio/audioInput.ts
-/** Audio input helpers: an encoded clip or raw microphone samples in, the
-*  16 kHz mono Float32Array the speech models take out. Both use the
-*  browser's own decoder and resampler through an OfflineAudioContext, so
-*  they run in the browser only. Importing the file is safe anywhere, the
-*  browser objects appear only inside the functions. */
-/** Sample rate the speech models take. */
-const SPEECH_SAMPLE_RATE = 16e3;
-/** Decodes any clip the browser can play (wav, mp3, ogg, ...) to 16 kHz
-*  mono samples. Stereo is mixed down to one channel. */
-async function decodeAudio(data) {
-	const decoded = await new OfflineAudioContext(1, 1, SPEECH_SAMPLE_RATE).decodeAudioData(data);
-	if (decoded.numberOfChannels === 1) return decoded.getChannelData(0);
-	const mix = new OfflineAudioContext(1, decoded.length, SPEECH_SAMPLE_RATE);
-	const src = mix.createBufferSource();
-	src.buffer = decoded;
-	src.connect(mix.destination);
-	src.start();
-	return (await mix.startRendering()).getChannelData(0);
-}
-/** Resamples raw mono samples recorded at `sourceRate` to 16 kHz. Returns
-*  the input as is when it is already at 16 kHz. Use it on microphone
-*  samples, a lossy re-encode is not needed. */
-async function resampleAudio(samples, sourceRate) {
-	if (sourceRate === 16e3) return samples;
-	const frames = Math.ceil(samples.length * SPEECH_SAMPLE_RATE / sourceRate);
-	const off = new OfflineAudioContext(1, frames, SPEECH_SAMPLE_RATE);
-	const buf = off.createBuffer(1, samples.length, sourceRate);
-	buf.copyToChannel(samples, 0);
-	const src = off.createBufferSource();
-	src.buffer = buf;
-	src.connect(off.destination);
-	src.start();
-	return (await off.startRendering()).getChannelData(0);
+		transcribe,
+		dispose: () => {
+			disposed = true;
+			dispose();
+		}
+	};
 }
 //#endregion
 //#region src/zoo/tasks/audio/speechToText.ts
@@ -907,6 +2761,9 @@ async function resampleAudio(samples, sourceRate) {
 const TICK_SAMPLES = SPEECH_SAMPLE_RATE / 2;
 /** Speech this long commits even without a pause. */
 const MAX_SEGMENT_SECONDS = 15;
+/** Decode budget of a preview, 1.5x the transcriber's default. A preview
+*  often ends mid-word, so the default cuts good text before its EOS. */
+const PREVIEW_TOKENS_PER_SECOND = 10;
 /** Loads the checkpoint and the tokenizer, warms every GPU path once, and
 *  returns the runner. With no config, loads Moonshine tiny from the
 *  Hugging Face Hub. */
@@ -922,7 +2779,7 @@ async function createSpeechToText(config = {}, opts = {}) {
 			...opts,
 			cacheId: opts.cacheId ?? cacheId(modelPath)
 		});
-		const tokenizer = moonshineTokenizerAsset(await fetchJson(tokenizerPath, {
+		const tokenizer = createMoonshineTokenizer(await fetchJson(tokenizerPath, {
 			...opts,
 			cacheId: cacheId(tokenizerPath)
 		}));
@@ -939,10 +2796,10 @@ async function createSpeechToText(config = {}, opts = {}) {
 		});
 		let disposed = false;
 		let queue = Promise.resolve();
-		const enqueue = (audio) => {
-			const run = queue.then(() => transcriber.transcribe(audio));
+		const enqueue = (audio, tokensPerSecond) => {
+			const run = queue.then(() => transcriber.transcribe(audio, tokensPerSecond));
 			queue = run.catch(() => void 0);
-			return run;
+			return run.catch(rethrowRunError);
 		};
 		let live;
 		async function* liveLoop(session) {
@@ -965,11 +2822,16 @@ async function createSpeechToText(config = {}, opts = {}) {
 						sampleRate: SPEECH_SAMPLE_RATE,
 						maxSegmentSeconds: MAX_SEGMENT_SECONDS
 					});
+					const commit = final || segment.shouldFinalize;
 					let text = "";
-					if (segment.hasSpeech && audio.length >= transcriber.minSamples) text = (await enqueue(audio)).text.trim();
-					else if (segment.seconds >= MAX_SEGMENT_SECONDS) keepTail(session, SPEECH_SAMPLE_RATE);
+					if (segment.hasSpeech && audio.length >= transcriber.minSamples) {
+						const result = await enqueue(audio, commit ? void 0 : PREVIEW_TOKENS_PER_SECOND);
+						text = result.text.trim();
+						const looped = result.ids.at(-1) !== tokenizer.eosId || repeatsPhrase(text);
+						if (!commit && looped) text = last.nonCommitted;
+					} else if (segment.seconds >= MAX_SEGMENT_SECONDS) keepTail(session, SPEECH_SAMPLE_RATE);
 					let committed = last.committed;
-					if (final || segment.shouldFinalize) {
+					if (commit) {
 						if (text) committed = committed ? `${committed} ${text}` : text;
 						text = "";
 						session.chunks = [];
@@ -990,14 +2852,14 @@ async function createSpeechToText(config = {}, opts = {}) {
 		}
 		return {
 			async transcribe(audio) {
-				if (disposed) throw new Error("speech to text is disposed");
-				if (!(audio instanceof Float32Array)) throw new Error("transcribe: audio must be a Float32Array");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "speech to text is disposed");
+				if (!(audio instanceof Float32Array)) throw new RunntimeError("INVALID_ARGUMENT", "transcribe: audio must be a Float32Array");
 				if (audio.length < transcriber.minSamples) return "";
 				return (await enqueue(audio)).text;
 			},
 			stream() {
-				if (disposed) throw new Error("speech to text is disposed");
-				if (live) throw new Error("stream: a stream is open, stop it first");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "speech to text is disposed");
+				if (live) throw new RunntimeError("INVALID_ARGUMENT", "stream: a stream is open, stop it first");
 				live = {
 					chunks: [],
 					length: 0,
@@ -1008,8 +2870,8 @@ async function createSpeechToText(config = {}, opts = {}) {
 				return liveLoop(live);
 			},
 			streamInsert(samples) {
-				if (!live || live.stopped) throw new Error("streamInsert: no stream is open");
-				if (!(samples instanceof Float32Array)) throw new Error("streamInsert: samples must be a Float32Array");
+				if (!live || live.stopped) throw new RunntimeError("INVALID_ARGUMENT", "streamInsert: no stream is open");
+				if (!(samples instanceof Float32Array)) throw new RunntimeError("INVALID_ARGUMENT", "streamInsert: samples must be a Float32Array");
 				live.chunks.push(samples.slice());
 				live.length += samples.length;
 				live.fresh += samples.length;
@@ -1033,7 +2895,7 @@ async function createSpeechToText(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 /** Joins the chunks into one array of `length` samples. */
@@ -1046,6 +2908,17 @@ function concat(chunks, length) {
 	}
 	return out;
 }
+/** True when some three words in a row appear twice. */
+function repeatsPhrase(text) {
+	const words = text.toLowerCase().match(/[\p{L}\p{N}']+/gu) ?? [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let i = 0; i + 3 <= words.length; i++) {
+		const phrase = words.slice(i, i + 3).join(" ");
+		if (seen.has(phrase)) return true;
+		seen.add(phrase);
+	}
+	return false;
+}
 /** Drops chunks from the front until about `samples` remain. */
 function keepTail(session, samples) {
 	while (session.chunks.length > 1 && session.length - session.chunks[0].length >= samples) session.length -= session.chunks.shift().length;
@@ -1276,49 +3149,6 @@ const COCO_NAMES = [
 	"toothbrush"
 ];
 //#endregion
-//#region src/zoo/tasks/cv/ops/point.ts
-/** The resize as numbers: how many input pixels one image pixel takes, and
-*  where the image's top-left corner lands inside the input. */
-function resizeTransform(options) {
-	const { from, to, resizeMode } = options;
-	switch (resizeMode) {
-		case "stretch": return {
-			scaleX: from.width / to.width,
-			scaleY: from.height / to.height,
-			offsetX: 0,
-			offsetY: 0
-		};
-		case "letterbox": {
-			const scale = Math.min(from.width / to.width, from.height / to.height);
-			return {
-				scaleX: scale,
-				scaleY: scale,
-				offsetX: (from.width - to.width * scale) / 2,
-				offsetY: (from.height - to.height * scale) / 2
-			};
-		}
-		case "crop": {
-			const side = Math.min(to.width, to.height) * (options.cropFraction ?? 1);
-			const scaleX = from.width / side;
-			const scaleY = from.height / side;
-			return {
-				scaleX,
-				scaleY,
-				offsetX: -(to.width - side) / 2 * scaleX,
-				offsetY: -(to.height - side) / 2 * scaleY
-			};
-		}
-	}
-}
-/** Maps a point from model-input coordinates to original-image coordinates. */
-function scalePoint(point, options) {
-	const { scaleX, scaleY, offsetX, offsetY } = resizeTransform(options);
-	return {
-		x: (point.x - offsetX) / scaleX,
-		y: (point.y - offsetY) / scaleY
-	};
-}
-//#endregion
 //#region src/zoo/tasks/cv/ops/box.ts
 /** Bounding boxes in three formats, plus scaling back onto the original image. */
 /** Builds a box from four numbers in the given format. */
@@ -1346,7 +3176,7 @@ function decodeBox(tuple, format) {
 			w: c,
 			h: d
 		};
-		default: throw new Error(`unknown box format ${String(format)}`);
+		default: throw new RunntimeError("INVALID_ARGUMENT", `unknown box format ${String(format)}`);
 	}
 }
 /** Maps a box from model-input coordinates to original-image coordinates. */
@@ -1399,203 +3229,6 @@ function scaleBox(box, options) {
 	}
 }
 //#endregion
-//#region src/zoo/tasks/cv/image.ts
-/** Bytes per pixel for each format. */
-const FORMAT_CHANNELS = {
-	rgb: 3,
-	rgba: 4,
-	bgr: 3,
-	bgra: 4,
-	gray: 1
-};
-/** Throws unless `width` and `height` are positive integers. */
-function checkImageSize(width, height, what = "image") {
-	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) throw new Error(`${what}: ${width}x${height} is not a positive size`);
-}
-/** Wraps raw bytes as an ImageBuffer. Checks the size and the byte count. */
-function imageBuffer(data, width, height, format = "rgba") {
-	checkImageSize(width, height);
-	const expected = width * height * FORMAT_CHANNELS[format];
-	if (data.length !== expected) throw new Error(`image: ${data.length} bytes for ${width}x${height} ${format}, expected ${expected}`);
-	return {
-		data,
-		width,
-		height,
-		format,
-		layout: "hwc"
-	};
-}
-/** Views canvas ImageData as an ImageBuffer. No copy. */
-function imageBufferFromImageData(img) {
-	return {
-		data: img.data,
-		width: img.width,
-		height: img.height,
-		format: "rgba",
-		layout: "hwc"
-	};
-}
-//#endregion
-//#region src/zoo/tasks/cv/utils/imagePreprocessor.ts
-/** CPU image preprocessor: any ImageBuffer in, the model's RGB CHW f32 input
-*  out. Resizes (stretch / letterbox / crop), converts the pixel format,
-*  moves channels first and normalizes, all in one pass over the output. */
-/** Index of the R, G and B byte inside one pixel of each format. */
-const RGB_INDEX = {
-	rgb: [
-		0,
-		1,
-		2
-	],
-	rgba: [
-		0,
-		1,
-		2
-	],
-	bgr: [
-		2,
-		1,
-		0
-	],
-	bgra: [
-		2,
-		1,
-		0
-	],
-	gray: [
-		0,
-		0,
-		0
-	]
-};
-function perChannel(v, name) {
-	if (typeof v === "number") return [
-		v,
-		v,
-		v
-	];
-	if (v.length !== 3) throw new Error(`normalize.${name}: expected 3 values, got ${v.length}`);
-	return [
-		v[0],
-		v[1],
-		v[2]
-	];
-}
-function buildAxis(outLen, srcLen, scale, offset, interpolation) {
-	const i0 = new Int32Array(outLen);
-	const i1 = new Int32Array(outLen);
-	const w = new Float32Array(outLen);
-	const inside = new Uint8Array(outLen);
-	for (let d = 0; d < outLen; d++) {
-		const s = (d + .5 - offset) / scale;
-		if (s < 0 || s >= srcLen) continue;
-		inside[d] = 1;
-		if (interpolation === "nearest") {
-			i0[d] = i1[d] = Math.min(srcLen - 1, Math.floor(s));
-			continue;
-		}
-		const f = s - .5;
-		const a = Math.floor(f);
-		i0[d] = Math.max(0, a);
-		i1[d] = Math.min(srcLen - 1, a + 1);
-		w[d] = a < 0 ? 0 : f - a;
-	}
-	return {
-		i0,
-		i1,
-		w,
-		inside
-	};
-}
-function createImagePreprocessor(options, size) {
-	const { width, height, resizeMode } = {
-		...size,
-		resizeMode: options.resizeMode
-	};
-	checkImageSize(width, height, "input size");
-	const interpolation = options.interpolation ?? "linear";
-	const cropFraction = options.cropFraction ?? 1;
-	if (!(cropFraction > 0 && cropFraction <= 1)) throw new Error(`cropFraction: expected a number in (0, 1], got ${cropFraction}`);
-	const padValue = options.padValue ?? 114;
-	const alpha = perChannel(options.normalizeOpts?.alpha ?? 1 / 255, "alpha");
-	const beta = perChannel(options.normalizeOpts?.beta ?? 0, "beta");
-	const hw = width * height;
-	const scaleOptions = (input) => ({
-		from: {
-			width,
-			height
-		},
-		to: {
-			width: input.width,
-			height: input.height
-		},
-		resizeMode,
-		cropFraction
-	});
-	const process = (input, out) => {
-		out ??= new Float32Array(3 * hw);
-		if (out.length !== 3 * hw) throw new Error(`out: ${out.length} floats, expected ${3 * hw}`);
-		checkImageSize(input.width, input.height);
-		const ch = FORMAT_CHANNELS[input.format];
-		const { data } = input;
-		if (data.length !== input.width * input.height * ch) throw new Error(`image: ${data.length} bytes for ${input.width}x${input.height} ${input.format}`);
-		const [ri, gi, bi] = RGB_INDEX[input.format];
-		const [ar, ag, ab] = alpha;
-		const [br, bg, bb] = beta;
-		const t = resizeTransform(scaleOptions(input));
-		if (t.scaleX === 1 && t.scaleY === 1 && t.offsetX === 0 && t.offsetY === 0) {
-			for (let i = 0; i < hw; i++) {
-				const p = i * ch;
-				out[i] = data[p + ri] * ar + br;
-				out[hw + i] = data[p + gi] * ag + bg;
-				out[2 * hw + i] = data[p + bi] * ab + bb;
-			}
-			return out;
-		}
-		const xs = buildAxis(width, input.width, t.scaleX, t.offsetX, interpolation);
-		const ys = buildAxis(height, input.height, t.scaleY, t.offsetY, interpolation);
-		const padR = padValue * ar + br;
-		const padG = padValue * ag + bg;
-		const padB = padValue * ab + bb;
-		const rowStride = input.width * ch;
-		for (let y = 0; y < height; y++) {
-			const rowIn = ys.inside[y];
-			const r0 = ys.i0[y] * rowStride;
-			const r1 = ys.i1[y] * rowStride;
-			const wy = ys.w[y];
-			for (let x = 0; x < width; x++) {
-				const o = y * width + x;
-				if (!rowIn || !xs.inside[x]) {
-					out[o] = padR;
-					out[hw + o] = padG;
-					out[2 * hw + o] = padB;
-					continue;
-				}
-				const c0 = xs.i0[x] * ch;
-				const c1 = xs.i1[x] * ch;
-				const wx = xs.w[x];
-				const w00 = (1 - wy) * (1 - wx);
-				const w01 = (1 - wy) * wx;
-				const w10 = wy * (1 - wx);
-				const w11 = wy * wx;
-				const r = data[r0 + c0 + ri] * w00 + data[r0 + c1 + ri] * w01 + data[r1 + c0 + ri] * w10 + data[r1 + c1 + ri] * w11;
-				const g = data[r0 + c0 + gi] * w00 + data[r0 + c1 + gi] * w01 + data[r1 + c0 + gi] * w10 + data[r1 + c1 + gi] * w11;
-				const b = data[r0 + c0 + bi] * w00 + data[r0 + c1 + bi] * w01 + data[r1 + c0 + bi] * w10 + data[r1 + c1 + bi] * w11;
-				out[o] = r * ar + br;
-				out[hw + o] = g * ag + bg;
-				out[2 * hw + o] = b * ab + bb;
-			}
-		}
-		return out;
-	};
-	return {
-		width,
-		height,
-		process,
-		scaleOptions
-	};
-}
-//#endregion
 //#region src/zoo/tasks/cv/objectDetection.ts
 /** Object detection task: an image in, the objects in it out, as labeled
 *  boxes. Runs YOLO26 on the initRunntime() device. */
@@ -1629,11 +3262,11 @@ async function createObjectDetector(config = {}, opts = {}) {
 		return {
 			labels,
 			async detectObjects(image, options = {}) {
-				if (disposed) throw new Error("object detector is disposed");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "object detector is disposed");
 				const { confidenceThreshold = .3, maxDetections = 300 } = options;
 				const run = queue.then(() => detector.run(preprocessor.process(image, pixels)));
 				queue = run.catch(() => void 0);
-				const { levels } = await run;
+				const { levels } = await run.catch(rethrowRunError);
 				const scale = preprocessor.scaleOptions(image);
 				return decodeDetections(levels, {
 					numClasses,
@@ -1667,7 +3300,7 @@ async function createObjectDetector(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 const clamp$2 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
@@ -1705,12 +3338,12 @@ async function createInstanceSegmenter(config = {}, opts = {}) {
 		return {
 			labels,
 			async segmentInstances(image, options = {}) {
-				if (disposed) throw new Error("instance segmenter is disposed");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "instance segmenter is disposed");
 				const { confidenceThreshold = .3, maxDetections = 300 } = options;
 				const run = queue.then(() => detector.run(preprocessor.process(image, pixels)));
 				queue = run.catch(() => void 0);
-				const { levels, proto } = await run;
-				if (!proto) throw new Error("yolo26 segment: the forward pass gave no mask prototypes");
+				const { levels, proto } = await run.catch(rethrowRunError);
+				if (!proto) throw new RunntimeError("EXECUTION_FAILED", "yolo26 segment: the forward pass gave no mask prototypes");
 				const scale = preprocessor.scaleOptions(image);
 				const toInput = resizeTransform(scale);
 				const protoStride = inputSize / proto.w;
@@ -1752,7 +3385,7 @@ async function createInstanceSegmenter(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 const clamp$1 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
@@ -1820,11 +3453,11 @@ async function createKeypointDetector(config = {}, opts = {}) {
 			landmarkNames: COCO_LANDMARKS,
 			skeleton: COCO_SKELETON.map(([a, b]) => [COCO_LANDMARKS[a], COCO_LANDMARKS[b]]),
 			async detectKeypoints(image, options = {}) {
-				if (disposed) throw new Error("keypoint detector is disposed");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "keypoint detector is disposed");
 				const { confidenceThreshold = .3, maxDetections = 300 } = options;
 				const run = queue.then(() => detector.run(preprocessor.process(image, pixels)));
 				queue = run.catch(() => void 0);
-				const { levels } = await run;
+				const { levels } = await run.catch(rethrowRunError);
 				const scale = preprocessor.scaleOptions(image);
 				return decodePoses(levels, {
 					numClasses,
@@ -1865,17 +3498,97 @@ async function createKeypointDetector(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
 //#endregion
+//#region src/zoo/tasks/gpu.ts
+/** GPU in, GPU out: the types every runner's encode<Verb> method takes, and
+*  how they are unwrapped from TypeGPU and checked. */
+/** Texture formats a GpuImage can have. sRGB formats are left out: the GPU
+*  decodes them to linear values, which are not the bytes the model expects. */
+const IMAGE_FORMATS = /* @__PURE__ */ new Set([
+	"rgba8unorm",
+	"bgra8unorm",
+	"rgb10a2unorm",
+	"rgba16float",
+	"rgba32float"
+]);
+/** Texture formats a GpuImageTarget can have: the float-renderable ones. */
+const TARGET_FORMATS = /* @__PURE__ */ new Set([
+	"r8unorm",
+	"r16float",
+	"r32float",
+	"rg8unorm",
+	"rg16float",
+	"rg32float",
+	"rgba8unorm",
+	"rgba8unorm-srgb",
+	"bgra8unorm",
+	"bgra8unorm-srgb",
+	"rgb10a2unorm",
+	"rgba16float",
+	"rgba32float"
+]);
+/** Unwraps a source and checks it. A tensor must hold at least `bytes`. */
+function unwrapSource(source, bytes) {
+	const raw = unwrap(source);
+	if ("mapState" in raw) {
+		checkBuffer(raw, bytes, GPUBufferUsage.COPY_SRC, "COPY_SRC", "source");
+		return { tensor: raw };
+	}
+	if ("format" in raw) checkImage(raw);
+	return { image: raw };
+}
+/** Unwraps a target and checks it. A tensor must hold at least `bytes`. */
+function unwrapTarget(target, bytes) {
+	const raw = unwrap(target);
+	if ("mapState" in raw) {
+		checkBuffer(raw, bytes, GPUBufferUsage.COPY_DST, "COPY_DST", "target");
+		return { tensor: raw };
+	}
+	if (!("format" in raw)) throw new RunntimeError("INVALID_ARGUMENT", "target: an external texture cannot be drawn into");
+	checkTexture(raw, "target", GPUTextureUsage.RENDER_ATTACHMENT, "RENDER_ATTACHMENT");
+	if (!TARGET_FORMATS.has(raw.format)) throw new RunntimeError("INVALID_ARGUMENT", `target: format ${raw.format} is not supported, use one of ${[...TARGET_FORMATS].join(", ")}`);
+	return { image: raw };
+}
+/** Runs `record` on the caller's encoder, or on a new one it then submits. */
+function encodeWith(encoder, record) {
+	const root = defaultRoot();
+	if (encoder !== void 0) {
+		record("resourceType" in encoder ? root.unwrap(encoder) : encoder);
+		return;
+	}
+	const own = root.device.createCommandEncoder();
+	record(own);
+	root.device.queue.submit([own.finish()]);
+}
+function unwrap(resource) {
+	if (isTexture(resource)) return defaultRoot().unwrap(resource);
+	if (isBuffer(resource)) return defaultRoot().unwrap(resource);
+	return resource;
+}
+function checkImage(texture) {
+	checkTexture(texture, "source", GPUTextureUsage.TEXTURE_BINDING, "TEXTURE_BINDING");
+	if (!IMAGE_FORMATS.has(texture.format)) throw new RunntimeError("INVALID_ARGUMENT", `source: format ${texture.format} is not supported, use one of ${[...IMAGE_FORMATS].join(", ")}`);
+	if (texture.depthOrArrayLayers !== 1) throw new RunntimeError("INVALID_ARGUMENT", `source: ${texture.depthOrArrayLayers} array layers, expected 1`);
+}
+function checkTexture(texture, what, usage, usageName) {
+	if (texture.dimension !== "2d" || texture.sampleCount !== 1) throw new RunntimeError("INVALID_ARGUMENT", `${what}: expected a 2d texture with one sample, got ${texture.dimension} with ${texture.sampleCount}`);
+	if (!(texture.usage & usage)) throw new RunntimeError("INVALID_ARGUMENT", `${what}: the texture needs ${usageName} usage`);
+}
+function checkBuffer(buffer, bytes, usage, usageName, what) {
+	if (buffer.size < bytes) throw new RunntimeError("INVALID_ARGUMENT", `${what}: buffer holds ${buffer.size} bytes, expected ${bytes}`);
+	if (!(buffer.usage & usage)) throw new RunntimeError("INVALID_ARGUMENT", `${what}: the buffer needs ${usageName} usage`);
+}
+//#endregion
 //#region src/zoo/tasks/cv/depthEstimation.ts
 /** Depth estimation task: an image in, a relative depth map out. Runs
 *  DepthART on the initRunntime() device. */
 /** Loads the checkpoint, warms the GPU path once, and returns the runner. */
 async function createDepthEstimator(config = {}, opts = {}) {
-	if (!supportsF16()) throw new Error("createDepthEstimator: this device has no shader-f16, which the conv kernels need. Request it with tgpu.init({ device: { optionalFeatures: ['shader-f16'] } })");
+	if (!supportsF16()) throw new RunntimeError("UNSUPPORTED_DEVICE", "createDepthEstimator: this device has no shader-f16, which the conv kernels need. Request it with tgpu.init({ device: { optionalFeatures: ['shader-f16'] } })");
 	const scope = createResourceScope();
 	try {
 		const { modelPath = models.depthEstimation.DEPTHART.DEFAULT.modelPath, variant, resizeMode = "stretch" } = config;
@@ -1902,20 +3615,51 @@ async function createDepthEstimator(config = {}, opts = {}) {
 			height: inputSize
 		});
 		const pixels = new Float32Array(3 * inputSize * inputSize);
+		const root = defaultRoot();
+		const imageToChw = createImageToChw(root);
+		const mapToTexture = scope.track(createMapToTexture(root));
+		const schemas = {
+			input: d.arrayOf(d.arrayOf(d.arrayOf(d.f32, inputSize), inputSize), 3),
+			output: d.arrayOf(d.arrayOf(d.f32, inputSize), inputSize)
+		};
+		const inputBytes = d.sizeOf(schemas.input);
+		const outputBytes = d.sizeOf(schemas.output);
 		let disposed = false;
 		let queue = Promise.resolve();
 		return {
 			inputSize,
+			schemas,
 			async estimateDepth(image) {
-				if (disposed) throw new Error("depth estimator is disposed");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "depth estimator is disposed");
 				const run = queue.then(() => estimator.run(preprocessor.process(image, pixels), inputSize, inputSize));
 				queue = run.catch(() => void 0);
 				return {
 					width: inputSize,
 					height: inputSize,
-					data: await run
+					data: await run.catch(rethrowRunError)
 				};
 			},
+			encodeEstimateDepth({ source, target, encoder, normalize = "none" }) {
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "depth estimator is disposed");
+				const src = unwrapSource(source, inputBytes);
+				const dst = unwrapTarget(target, outputBytes);
+				if ("tensor" in dst && normalize !== "none") throw new RunntimeError("INVALID_ARGUMENT", "normalize: only a texture target is rescaled");
+				try {
+					encodeWith(encoder, (enc) => estimator.encode(enc, (input) => {
+						if ("tensor" in src) enc.copyBufferToBuffer(src.tensor, 0, root.unwrap(input), 0, inputBytes);
+						else imageToChw.encode(enc, src.image, input, preprocessor.gpuArgs);
+					}, (depth) => {
+						if ("tensor" in dst) enc.copyBufferToBuffer(root.unwrap(depth), 0, dst.tensor, 0, outputBytes);
+						else mapToTexture.encode(enc, depth, dst.image, {
+							width: inputSize,
+							height: inputSize,
+							normalize
+						});
+					}));
+				} catch (err) {
+					rethrowRunError(err);
+				}
+			},
 			dispose() {
 				disposed = true;
 				scope.dispose();
@@ -1923,7 +3667,7 @@ async function createDepthEstimator(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 //#endregion
@@ -2956,7 +4700,7 @@ function decodeTopK(logits, k = 5) {
 /** Loads the checkpoint, warms the GPU path once, and returns the runner.
 *  Needs a device with `shader-f16`. */
 async function createImageClassifier(config = {}, opts = {}) {
-	if (!supportsF16()) throw new Error("createImageClassifier: this device has no shader-f16, which the conv kernels need. Request it with tgpu.init({ device: { optionalFeatures: ['shader-f16'] } })");
+	if (!supportsF16()) throw new RunntimeError("UNSUPPORTED_DEVICE", "createImageClassifier: this device has no shader-f16, which the conv kernels need. Request it with tgpu.init({ device: { optionalFeatures: ['shader-f16'] } })");
 	const scope = createResourceScope();
 	try {
 		const { modelPath = models.imageClassification.MOBILENETV4.DEFAULT.modelPath, labels = IMAGENET1K_LABELS, resizeMode = "crop" } = config;
@@ -2968,7 +4712,7 @@ async function createImageClassifier(config = {}, opts = {}) {
 		throwIfAborted(opts.signal);
 		const classifier = scope.track(await createClassifier(sd, { onProgress: opts.onProgress }));
 		const { inputSize, numClasses } = classifier;
-		if (labels.length !== numClasses) throw new Error(`labels: ${labels.length} names for a ${numClasses}-class model`);
+		if (labels.length !== numClasses) throw new RunntimeError("INVALID_ARGUMENT", `labels: ${labels.length} names for a ${numClasses}-class model`);
 		const preprocessor = createImagePreprocessor({
 			resizeMode,
 			cropFraction: MOBILENETV4_CROP_FRACTION,
@@ -2987,12 +4731,12 @@ async function createImageClassifier(config = {}, opts = {}) {
 			labels,
 			inputSize,
 			async classify(image, options = {}) {
-				if (disposed) throw new Error("image classifier is disposed");
+				if (disposed) throw new RunntimeError("RESOURCE_DISPOSED", "image classifier is disposed");
 				const { topk = numClasses } = options;
-				if (!Number.isInteger(topk) || topk < 1) throw new Error(`classify: topk must be a positive integer, got ${topk}`);
+				if (!Number.isInteger(topk) || topk < 1) throw new RunntimeError("INVALID_ARGUMENT", `classify: topk must be a positive integer, got ${topk}`);
 				const run = queue.then(() => classifier.run(preprocessor.process(image, pixels)));
 				queue = run.catch(() => void 0);
-				return decodeTopK(await run, Math.min(topk, numClasses)).map(({ classId, confidence }) => ({
+				return decodeTopK(await run.catch(rethrowRunError), Math.min(topk, numClasses)).map(({ classId, confidence }) => ({
 					label: labels[classId],
 					classId,
 					confidence
@@ -3005,8 +4749,8 @@ async function createImageClassifier(config = {}, opts = {}) {
 		};
 	} catch (err) {
 		scope.dispose();
-		throw err;
+		throw asLoadError(err, opts.signal);
 	}
 }
 //#endregion
-export { COCO_LANDMARKS, SPEECH_SAMPLE_RATE, bufferSource, createDepthEstimator, createImageClassifier, createInstanceSegmenter, createKeypointDetector, createObjectDetector, createOpfsCache, createPrivacyFilter, createSpeechToText, createTextEmbedder, decodeAudio, imageBuffer, imageBufferFromImageData, initRunntime, models, resampleAudio, similarity };
+export { COCO_LANDMARKS, RUNNTIME_ERROR_CODES, RunntimeError, SPEECH_SAMPLE_RATE, bufferSource, createDepthEstimator, createEmbedder, createImageClassifier, createInstanceSegmenter, createKeypointDetector, createObjectDetector, createOpfsCache, createPrivacyFilter, createSpeechToText, decodeAudio, imageBuffer, imageBufferFromImageData, initRunntime, isRunntimeError, models, resampleAudio, similarity };