runntime 0.0.1-alpha.0 → 0.0.1-beta.1

package/dist/zoo/index.mjs

@@ -0,0 +1,3012 @@
+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";
+//#region src/core/lifetime.ts
+function createResourceScope() {
+	const tracked = [];
+	let disposed = false;
+	return {
+		track(resource) {
+			tracked.push(resource);
+			return resource;
+		},
+		dispose() {
+			disposed = true;
+			for (const r of tracked.splice(0).reverse()) r.dispose();
+		},
+		get disposed() {
+			return disposed;
+		}
+	};
+}
+//#endregion
+//#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. */
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new Error("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. */
+async function openWeights(modelPath, opts = {}) {
+	throwIfAborted(opts.signal);
+	try {
+		return await fromSafetensors(modelPath, {
+			onBytes: opts.onBytes,
+			cache: opts.cache,
+			cacheId: opts.cacheId
+		});
+	} catch (err) {
+		throw new Error(`${typeof modelPath === "string" ? modelPath : "weights"}: ${err.message}`, { 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. */
+async function fetchJson(url, opts = {}) {
+	throwIfAborted(opts.signal);
+	const download = async () => {
+		let res;
+		try {
+			res = await fetch(url, { signal: opts.signal });
+		} catch (err) {
+			throw new Error(`${url}: ${err.message}`, { cause: err });
+		}
+		if (!res.ok) throw new Error(`${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
+		};
+	}
+	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;
+	const idOf = (token) => {
+		const id = hf.model.vocab[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
+	};
+}
+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);
+};
+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;
+		}
+		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--;
+			}
+			if (id === void 0) {
+				out.push(asset.unkId);
+				return;
+			}
+			pieces.push(id);
+			start = end;
+		}
+		out.push(...pieces);
+	};
+	return {
+		clsId: asset.clsId,
+		sepId: asset.sepId,
+		encode(text) {
+			const pieces = [];
+			for (const word of basicTokenize(text, asset.doLowerCase)) wordpiece(word, pieces);
+			const body = pieces.slice(0, asset.maxWordpieces - 2);
+			return [
+				asset.clsId,
+				...body,
+				asset.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. */
+function similarity(a, b) {
+	let dot = 0;
+	for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
+	return dot;
+}
+const normalize = (v) => {
+	let sumSq = 0;
+	for (const x of v) sumSq += x * x;
+	const inv = 1 / Math.sqrt(sumSq);
+	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 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, {
+			...opts,
+			cacheId: opts.cacheId ?? cacheId(modelPath)
+		});
+		const tokenizer = createMinilmTokenizer(minilmTokenizerAsset(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));
+		let disposed = false;
+		const guard = () => {
+			if (disposed) throw new Error("text 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)));
+		};
+		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) {
+				guard();
+				return embedTokens(tokenizer.encode(input));
+			},
+			async embedBatch(inputs) {
+				guard();
+				return embedTokensBatch(inputs.map((t) => tokenizer.encode(t)));
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+//#endregion
+//#region src/zoo/tasks/nlp/privacyFilter.ts
+/** Privacy filter task: text in, the personal data it contains out, as
+*  labeled spans. Runs OpenAI's privacy-filter on the initRunntime() device. */
+/** Loads the checkpoint, warms the GPU path once, and returns the runner. */
+async function createPrivacyFilter(config = {}, opts = {}) {
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.privacyFilter.PRIVACY_FILTER.DEFAULT.modelPath } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `privacy-filter-v1/${path}`)
+		});
+		throwIfAborted(opts.signal);
+		const detector = scope.track(await createDetector(sd, { onProgress: opts.onProgress }));
+		let disposed = false;
+		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");
+				const run = queue.then(() => detector.detect(text));
+				queue = run.catch(() => void 0);
+				return (await run).spans;
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+//#endregion
+//#region src/zoo/moonshine/segmenter.ts
+function analyzeSegment(audio, opts) {
+	const { sampleRate, threshold = .015, hopSeconds = .032, smoothHops = 8, silenceSeconds = .8, maxSegmentSeconds = 15 } = opts;
+	if (!(sampleRate > 0)) throw new Error(`analyzeSegment: bad sampleRate ${sampleRate}`);
+	if (!(threshold > 0)) throw new Error(`analyzeSegment: threshold must be positive`);
+	const hop = Math.max(1, Math.round(hopSeconds * sampleRate));
+	const seconds = audio.length / sampleRate;
+	const hops = Math.ceil(audio.length / hop);
+	const rms = new Float64Array(hops);
+	for (let h = 0; h < hops; h++) {
+		const start = h * hop;
+		const end = Math.min(start + hop, audio.length);
+		let sum = 0;
+		for (let i = start; i < end; i++) sum += audio[i] * audio[i];
+		rms[h] = Math.sqrt(sum / (end - start));
+	}
+	let lastSpeech = -1;
+	let windowSum = 0;
+	for (let h = 0; h < hops; h++) {
+		windowSum += rms[h];
+		if (h >= smoothHops) windowSum -= rms[h - smoothHops];
+		if (windowSum / Math.min(h + 1, smoothHops) > threshold) lastSpeech = h;
+	}
+	const hasSpeech = lastSpeech >= 0;
+	const trailingSilenceSeconds = hasSpeech ? (hops - 1 - lastSpeech) * hop / sampleRate : seconds;
+	return {
+		seconds,
+		hasSpeech,
+		trailingSilenceSeconds,
+		shouldFinalize: hasSpeech && (trailingSilenceSeconds >= silenceSeconds || seconds >= maxSegmentSeconds)
+	};
+}
+//#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({
+	enc: Object.freeze({
+		hidden: 320,
+		ffn: 1280,
+		layers: 6,
+		heads: 8,
+		headDim: 40,
+		windows: windows(6)
+	}),
+	dec: Object.freeze({
+		hidden: 320,
+		ffn: 1280,
+		layers: 6,
+		heads: 8,
+		headDim: 40,
+		rotaryDim: 32,
+		ropeTheta: 1e4
+	}),
+	frameLen: 80,
+	vocab: 32768,
+	maxPositions: 4096,
+	bos: 1,
+	eos: 2
+});
+const MOONSHINE_STREAMING_SMALL = Object.freeze({
+	enc: Object.freeze({
+		hidden: 620,
+		ffn: 2480,
+		layers: 10,
+		heads: 8,
+		headDim: 64,
+		windows: windows(10)
+	}),
+	dec: Object.freeze({
+		hidden: 512,
+		ffn: 2048,
+		layers: 10,
+		heads: 8,
+		headDim: 64,
+		rotaryDim: 32,
+		ropeTheta: 1e4
+	}),
+	frameLen: 80,
+	vocab: 32768,
+	maxPositions: 4096,
+	bos: 1,
+	eos: 2
+});
+const MOONSHINE_STREAMING_MEDIUM = Object.freeze({
+	enc: Object.freeze({
+		hidden: 768,
+		ffn: 3072,
+		layers: 14,
+		heads: 10,
+		headDim: 64,
+		windows: windows(14)
+	}),
+	dec: Object.freeze({
+		hidden: 640,
+		ffn: 2560,
+		layers: 14,
+		heads: 10,
+		headDim: 64,
+		rotaryDim: 32,
+		ropeTheta: 1e4
+	}),
+	frameLen: 80,
+	vocab: 32768,
+	maxPositions: 4096,
+	bos: 1,
+	eos: 2
+});
+function presetFromStateDict(sd) {
+	const embedding = sd.tensors.get("model.decoder.embed_tokens.weight");
+	const width = embedding?.shape[1];
+	const presets = [
+		MOONSHINE_STREAMING_TINY,
+		MOONSHINE_STREAMING_SMALL,
+		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`);
+}
+//#endregion
+//#region src/zoo/moonshine-streaming/frontend.ts
+/** Moonshine v2 frontend: raw 16 kHz mono audio, reshaped on the CPU into
+*  non-overlapping 80-sample frames [T, 80] (5 ms, 200 Hz), → encoder frames
+*  [T/4, enc.hidden] (~50 Hz):
+*      per-frame CMVN → asinh(k·x) → linear [80 → d] (no bias) → silu
+*      → causal conv1 k=5 s=2 (d → 2d) → silu → causal conv2 k=5 s=2 (2d → d)
+*  CMVN (mean-center, divide by RMS, eps 1e-6) is exactly a bias-free
+*  LayerNorm whose weight the loader supplies as ones. k is the checkpoint's
+*  learnable asinh compression scale — a [1] Parameter holding exp(log_k),
+*  broadcast-multiplied before the asinh. Both convs left-pad kernel−1 zeros
+*  (causal), so each keeps ceil(T/2) frames; no activation after conv2. */
+const K = 5;
+const S = 2;
+const PAD = 4;
+function frontendFrames(samples, frameLen) {
+	if (!Number.isInteger(samples) || samples < frameLen || samples % frameLen !== 0) throw new Error(`frontendFrames: samples ${samples} must be a positive multiple of frameLen ${frameLen}`);
+	const input = samples / frameLen;
+	const conv1 = Math.floor((input - 1) / S) + 1;
+	return {
+		input,
+		conv1,
+		conv2: Math.floor((conv1 - 1) / S) + 1
+	};
+}
+var StreamingFrontend = class extends Module {
+	cmvn;
+	k;
+	linear;
+	conv1;
+	conv2;
+	constructor(cfg) {
+		super();
+		const d = cfg.enc.hidden;
+		this.cmvn = new LayerNorm(cfg.frameLen, 1e-6);
+		this.k = new Parameter({
+			elems: 1,
+			dtype: "f32",
+			dims: [1]
+		});
+		this.linear = new Linear(cfg.frameLen, d, { bias: false });
+		this.conv1 = new Conv1d(d, 2 * d, K, {
+			stride: S,
+			padLeft: PAD
+		});
+		this.conv2 = new Conv1d(2 * d, d, K, {
+			stride: S,
+			padLeft: PAD
+		});
+	}
+	forward(x) {
+		const compressed = asinh(mul(this.cmvn.forward(x), this.k.value));
+		const h = silu(this.conv1.forward(silu(this.linear.forward(compressed))));
+		return this.conv2.forward(h);
+	}
+};
+//#endregion
+//#region src/zoo/moonshine-streaming/encoder.ts
+/** Moonshine v2 encoder: pre-norm transformer layers carrying no positional
+*  information. Locality comes entirely from per-layer asymmetric
+*  sliding-window attention, with windows converted from HF's strict bounds to
+*  the kernel's inclusive form.
+*
+*  There is no rope, so the score scale folds into the q columns at load. The
+*  loader also adds 1 back to the checkpoint's offset norm gamma, so plain
+*  weight-only LayerNorms serve here.
+*
+*  The adapter bridges encoder to decoder, and is where positions enter. */
+var EncoderAttn = class extends Module {
+	cfg;
+	qkv;
+	mha;
+	out;
+	constructor(cfg, window) {
+		super();
+		this.cfg = cfg;
+		const { hidden, heads, headDim } = cfg.enc;
+		const qw = heads * headDim;
+		this.qkv = new Linear(hidden, 3 * qw, { bias: false });
+		this.mha = new MultiHeadAttention({
+			qHeads: heads,
+			kvHeads: heads,
+			headDim,
+			windowLeft: window[0] - 1,
+			windowRight: Math.max(0, window[1] - 1)
+		});
+		this.out = new Linear(qw, hidden, { bias: false });
+	}
+	forward(x, residual) {
+		const qkv = this.qkv.forward(x);
+		const [q, k, v] = chunk(qkv, 3, 1);
+		return this.out.forward(this.mha.forward(q, k, v), { addend: residual });
+	}
+};
+var EncoderMlp = class extends Module {
+	fc1;
+	fc2;
+	constructor(cfg) {
+		super();
+		this.fc1 = new Linear(cfg.enc.hidden, cfg.enc.ffn);
+		this.fc2 = new Linear(cfg.enc.ffn, cfg.enc.hidden);
+	}
+	forward(x, residual) {
+		return this.fc2.forward(gelu(this.fc1.forward(x)), { addend: residual });
+	}
+};
+var EncoderLayer = class extends Module {
+	norm1;
+	attn;
+	norm2;
+	mlp;
+	constructor(cfg, window) {
+		super();
+		this.norm1 = new LayerNorm(cfg.enc.hidden);
+		this.attn = new EncoderAttn(cfg, window);
+		this.norm2 = new LayerNorm(cfg.enc.hidden);
+		this.mlp = new EncoderMlp(cfg);
+	}
+	forward(x) {
+		const h = this.attn.forward(this.norm1.forward(x), x);
+		return this.mlp.forward(this.norm2.forward(h), h);
+	}
+};
+var StreamingEncoder = class extends Module {
+	layers;
+	norm;
+	constructor(cfg) {
+		super();
+		this.layers = new ModuleList(cfg.enc.windows.map((w) => new EncoderLayer(cfg, w)));
+		this.norm = new LayerNorm(cfg.enc.hidden);
+	}
+	forward(x) {
+		let h = x;
+		for (const layer of this.layers.items) h = layer.forward(h);
+		return this.norm.forward(h);
+	}
+};
+var StreamingAdapter = class extends Module {
+	posEmb;
+	proj;
+	constructor(cfg) {
+		super();
+		const [eh, dh] = [cfg.enc.hidden, cfg.dec.hidden];
+		this.posEmb = new Parameter({
+			elems: cfg.maxPositions * eh,
+			dtype: "f32",
+			dims: [cfg.maxPositions, eh]
+		});
+		this.proj = eh === dh ? void 0 : new Linear(eh, dh, { bias: false });
+	}
+	forward(x) {
+		const t = x.shape.dims[0];
+		const positioned = add(x, slice(this.posEmb.value, 0, 0, t));
+		return this.proj ? this.proj.forward(positioned) : positioned;
+	}
+};
+//#endregion
+//#region src/zoo/moonshine-streaming/stateDictHooks.ts
+/** Maps the HF Moonshine v2 checkpoint onto the model's parameter tree as lazy
+*  derived tensors; nothing is fetched here.
+*
+*  The notable transforms: encoder norm gamma gains back its −1 offset, CMVN's
+*  missing weight is synthesized as ones, and q/k/v stack into fused weights —
+*  scaled on the encoder, which has no rope, and unscaled on the decoder, whose
+*  rope tables carry the scale. Everything else renames.
+*
+*  Weights stay in torch layout for the core Linear and Conv1d hooks to
+*  transpose. Derived byteLengths carry the source file bytes, so load progress
+*  still sums to the checkpoint size. */
+function gammaPlusOne(t) {
+	return derivedTensor(t.shape, async () => {
+		const gamma = await t.f32();
+		const out = new Float32Array(gamma.length);
+		for (let j = 0; j < gamma.length; j++) out[j] = gamma[j] + 1;
+		return out;
+	}, t.byteLength);
+}
+function transformStreamingStateDict(sd, prefix, cfg) {
+	const q = (name) => qualify(prefix, name);
+	const [eh, dh] = [cfg.enc.hidden, cfg.dec.hidden];
+	const gammaNorm = (from, to) => sd.tensors.set(to, gammaPlusOne(take(sd, from)));
+	moveTiedEmbedding(sd, prefix);
+	sd.tensors.set(q("frontend.cmvn.weight"), derivedTensor([cfg.frameLen], async () => new Float32Array(cfg.frameLen).fill(1), 0));
+	const logK = take(sd, q("model.encoder.embedder.comp.log_k"));
+	sd.tensors.set(q("frontend.k"), derivedTensor([1], async () => Float32Array.from([Math.exp((await logK.f32())[0])]), logK.byteLength));
+	move(sd, q("model.encoder.embedder.linear.weight"), q("frontend.linear.weight"));
+	move(sd, q("model.encoder.embedder.conv1.weight"), q("frontend.conv1.weight"));
+	move(sd, q("model.encoder.embedder.conv1.bias"), q("frontend.conv1.bias"));
+	move(sd, q("model.encoder.embedder.conv2.weight"), q("frontend.conv2.weight"));
+	move(sd, q("model.encoder.embedder.conv2.bias"), q("frontend.conv2.bias"));
+	const encQScale = 1 / Math.sqrt(cfg.enc.headDim);
+	for (let i = 0; i < cfg.enc.layers; i++) {
+		const hf = q(`model.encoder.layers.${i}`);
+		const en = q(`encoder.layers.${i}`);
+		gammaNorm(`${hf}.input_layernorm.gamma`, `${en}.norm1.weight`);
+		fuseQkv(sd, `${hf}.self_attn`, `${en}.attn.qkv.weight`, eh, encQScale);
+		move(sd, `${hf}.self_attn.o_proj.weight`, `${en}.attn.out.weight`);
+		gammaNorm(`${hf}.post_attention_layernorm.gamma`, `${en}.norm2.weight`);
+		move(sd, `${hf}.mlp.fc1.weight`, `${en}.mlp.fc1.weight`);
+		move(sd, `${hf}.mlp.fc1.bias`, `${en}.mlp.fc1.bias`);
+		move(sd, `${hf}.mlp.fc2.weight`, `${en}.mlp.fc2.weight`);
+		move(sd, `${hf}.mlp.fc2.bias`, `${en}.mlp.fc2.bias`);
+	}
+	gammaNorm(q("model.encoder.final_norm.gamma"), q("encoder.norm.weight"));
+	move(sd, q("model.decoder.pos_emb.weight"), q("adapter.posEmb"));
+	if (eh !== dh) move(sd, q("model.decoder.proj.weight"), q("adapter.proj.weight"));
+	transformDecoder(sd, prefix, {
+		layers: cfg.dec.layers,
+		hidden: dh,
+		headDim: cfg.dec.headDim
+	});
+}
+//#endregion
+//#region src/zoo/moonshine-streaming/model.ts
+/** The full Moonshine v2 module tree. No constructor takes a sequence length,
+*  and one loadStateDict binds the whole checkpoint.
+*
+*  The decoder is the v1 class: same architecture, different dims, so
+*  `decoderView` bridges the two config shapes. Cross K and V read the adapter
+*  output rather than the encoder's.
+*
+*  The embedding weight serves as both token lookup and the tied LM head. No
+*  transposed copy exists, so tying is exact by construction. */
+function decoderView(cfg) {
+	return {
+		dModel: cfg.dec.hidden,
+		ffn: cfg.dec.ffn,
+		encLayers: cfg.enc.layers,
+		decLayers: cfg.dec.layers,
+		heads: cfg.dec.heads,
+		headDim: cfg.dec.headDim,
+		rotaryDim: cfg.dec.rotaryDim,
+		ropeTheta: cfg.dec.ropeTheta,
+		vocab: cfg.vocab,
+		maxPositions: cfg.maxPositions,
+		bos: cfg.bos,
+		eos: cfg.eos
+	};
+}
+var MoonshineStreamingModel = class extends Module {
+	cfg;
+	embedding;
+	frontend;
+	encoder;
+	adapter;
+	decoder;
+	constructor(cfg) {
+		super();
+		this.cfg = cfg;
+		this.embedding = new Embedding(cfg.vocab, cfg.dec.hidden);
+		this.frontend = new StreamingFrontend(cfg);
+		this.encoder = new StreamingEncoder(cfg);
+		this.adapter = new StreamingAdapter(cfg);
+		this.decoder = new MoonshineDecoder(decoderView(cfg));
+	}
+	transformStateDict(sd, prefix) {
+		transformStreamingStateDict(sd, prefix, this.cfg);
+	}
+	embed(ids) {
+		return this.embedding.forward(ids);
+	}
+	embedFrom(ids) {
+		return gatherRowsFrom(this.embedding.weight.value, ids);
+	}
+	logitsLast(h) {
+		const w = this.embedding.weight.value;
+		if (w.shape.dtype !== h.shape.dtype) throw new Error(`MoonshineStreamingModel.logitsLast: embedding is ${w.shape.dtype} but h is ${h.shape.dtype}`);
+		const t = h.shape.dims[0];
+		return matmul(w, transpose(slice(h, 0, t - 1, t)));
+	}
+	nextTokenId(h1) {
+		return argmaxDot(this.embedding.weight.value, h1);
+	}
+	forward() {
+		throw new Error("MoonshineStreamingModel: use frontend/encoder/adapter/decoder forwards, embed() and logitsLast()");
+	}
+};
+//#endregion
+//#region src/zoo/moonshine-streaming/transcriber.ts
+/** Streaming Moonshine transcriber: the v1 decode loop over the v2 frontend,
+*  encoder and adapter. Long clips split on quiet points into per-utterance
+*  chunks; each utterance is zero-padded to whole 80-sample frames.
+*
+*  Decoding runs in bursts: within a burst each step's argmax id feeds the next
+*  step's embedding on device, so the GPU runs the whole burst with no CPU
+*  round-trip. A burst may overshoot EOS; those ids are discarded.
+*
+*  Rope tables and the per-layer K/V caches are allocated once at
+*  DECODE_POSITIONS rows and written in place, so utterances reuse them and
+*  transcribe() calls must stay sequential. */
+const SAMPLE_RATE = 16e3;
+const TOKENS_PER_SECOND = 6.5;
+const BURST = 8;
+const DECODE_POSITIONS = 256;
+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'`);
+	const cfg = opts.cfg ?? presetFromStateDict(sd);
+	const dec = decoderView(cfg);
+	const perf = opts.perf;
+	const burstMax = Math.max(1, Math.min(perf?.burst ?? BURST, DECODE_POSITIONS));
+	const ex = gpuExecutor(root, { perf: perf?.gpuPerf });
+	const half = opts.weightDtype === "f16";
+	const model = new MoonshineStreamingModel(cfg);
+	if (half) model.half(root);
+	try {
+		await model.loadStateDict(sd, {
+			root,
+			onProgress: opts.onProgress
+		});
+	} catch (err) {
+		model.dispose();
+		throw err;
+	}
+	const actTensor = (data, dims) => tensor(root, data, {
+		elems: data.length,
+		dtype: half ? "f16" : "f32",
+		dims
+	});
+	const tables = buildRopeTables(DECODE_POSITIONS, dec);
+	const decCos = tensor(root, tables.cos, [DECODE_POSITIONS, dec.headDim]);
+	const decSin = tensor(root, tables.sin, [DECODE_POSITIONS, dec.headDim]);
+	const qw = dec.heads * dec.headDim;
+	const kvInit = new Float32Array(DECODE_POSITIONS * qw);
+	const selfKV = Array.from({ length: dec.decLayers }, () => ({
+		k: actTensor(kvInit, [DECODE_POSITIONS, qw]),
+		v: actTensor(kvInit, [DECODE_POSITIONS, qw])
+	}));
+	const idsBuf = tensor(root, new Float32Array(DECODE_POSITIONS), [DECODE_POSITIONS, 1]);
+	const padToFrames = (audio) => {
+		if (audio.length === 0) throw new Error("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) => {
+		perf?.onPhase?.("encode");
+		const t0 = performance.now();
+		const audio = padToFrames(rawAudio);
+		const frames = frontendFrames(audio.length, cfg.frameLen);
+		const x = actTensor(audio, [frames.input, cfg.frameLen]);
+		const adapterOut = model.adapter.forward(model.encoder.forward(model.frontend.forward(x)));
+		const cross = model.decoder.precomputeCrossKV(adapterOut);
+		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 release = (kvs) => {
+			for (const { k, v } of kvs) {
+				ex.releaseOutput(k.buffer, k.shape);
+				k.markReleased();
+				ex.releaseOutput(v.buffer, v.shape);
+				v.markReleased();
+			}
+		};
+		ex.releaseOutput(adapterOut.buffer, adapterOut.shape);
+		adapterOut.markReleased();
+		const ids = [cfg.bos];
+		perf?.onPhase?.("decode");
+		const t1 = performance.now();
+		decode: while (ids.length < maxTokens) {
+			const base = ids.length - 1;
+			const burst = Math.min(burstMax, maxTokens - ids.length);
+			const tBuild = performance.now();
+			const idRows = [];
+			let x1 = model.embed([ids[base]]);
+			for (let j = 0; j < burst; j++) {
+				const t = base + j;
+				const h = model.decoder.forwardStep(x1, slice(decCos, 0, t, t + 1), slice(decSin, 0, t, t + 1), cross, selfKV, t);
+				const idVal = model.nextTokenId(h);
+				idRows.push(writeRows(idsBuf, idVal, t));
+				if (j + 1 < burst) x1 = model.embedFrom(idVal);
+			}
+			const tEval = performance.now();
+			evalValues(idRows, ex);
+			const tRead = performance.now();
+			const data = await ex.readback(idsBuf.buffer, {
+				elems: base + burst,
+				dtype: "f32",
+				dims: [base + burst, 1]
+			});
+			perf?.onBurst?.({
+				positions: burst,
+				buildMs: tEval - tBuild,
+				evalMs: tRead - tEval,
+				readbackMs: performance.now() - tRead
+			});
+			for (let j = 0; j < burst; j++) {
+				const best = data[base + j];
+				ids.push(best);
+				if (best === cfg.eos) break decode;
+			}
+		}
+		release(cross);
+		return {
+			ids,
+			text: decodeTokens(tokenizer, ids),
+			timings: {
+				encodeMs,
+				decodeMs: performance.now() - t1,
+				steps: ids.length - 1
+			}
+		};
+	};
+	const chunkOpts = {
+		maxSeconds: opts.chunking?.maxSeconds ?? MAX_CHUNK_SECONDS,
+		searchSeconds: opts.chunking?.searchSeconds ?? SPLIT_SEARCH_SECONDS,
+		sampleRate: SAMPLE_RATE
+	};
+	const transcribeAll = async (audio) => {
+		const chunks = splitIntoChunks(audio, chunkOpts);
+		if (chunks.length === 1) return transcribeUtterance(audio);
+		const results = [];
+		for (const chunk of chunks) results.push(await transcribeUtterance(chunk));
+		return {
+			ids: results.flatMap((r) => r.ids),
+			text: results.map((r) => r.text.trim()).filter((t) => t.length > 0).join(" "),
+			timings: results.reduce((sum, r) => ({
+				encodeMs: sum.encodeMs + r.timings.encodeMs,
+				decodeMs: sum.decodeMs + r.timings.decodeMs,
+				steps: sum.steps + r.timings.steps
+			}), {
+				encodeMs: 0,
+				decodeMs: 0,
+				steps: 0
+			})
+		};
+	};
+	const dispose = () => {
+		model.dispose();
+		for (const v of [
+			decCos,
+			decSin,
+			idsBuf,
+			...selfKV.flatMap((kv) => [kv.k, kv.v])
+		]) v.buffer.destroy();
+		ex.dispose();
+	};
+	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));
+		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);
+}
+//#endregion
+//#region src/zoo/tasks/audio/speechToText.ts
+/** Speech to text task: 16 kHz mono audio in, as a clip or live from the
+*  microphone, text out. Runs Moonshine on the initRunntime() device. */
+/** New audio between two transcriptions of the sentence being spoken. */
+const TICK_SAMPLES = SPEECH_SAMPLE_RATE / 2;
+/** Speech this long commits even without a pause. */
+const MAX_SEGMENT_SECONDS = 15;
+/** 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. */
+async function createSpeechToText(config = {}, opts = {}) {
+	const scope = createResourceScope();
+	try {
+		const device = defaultRoot().device;
+		const arch = config.arch ?? "moonshine";
+		const defaults = arch === "moonshine" ? models.speechToText.MOONSHINE.TINY.DEFAULT : models.speechToText.MOONSHINE_STREAMING.TINY.DEFAULT;
+		const { modelPath = defaults.modelPath, tokenizerPath = defaults.tokenizerPath, dtype = supportsF16() ? "f16" : "f32" } = config;
+		const cacheId = (path) => typeof path === "string" ? `${arch}-v1/${path.replace(/^https?:\/\//, "")}` : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? cacheId(modelPath)
+		});
+		const tokenizer = moonshineTokenizerAsset(await fetchJson(tokenizerPath, {
+			...opts,
+			cacheId: cacheId(tokenizerPath)
+		}));
+		throwIfAborted(opts.signal);
+		const make = arch === "moonshine" ? createTranscriber$1 : createTranscriber;
+		const transcriber = scope.track(await make(sd, tokenizer, {
+			weightDtype: dtype,
+			onProgress: opts.onProgress
+		}));
+		throwIfAborted(opts.signal);
+		await warmUp(device, async () => {
+			const silence = new Float32Array(SPEECH_SAMPLE_RATE);
+			return Float32Array.from((await transcriber.transcribe(silence)).ids);
+		});
+		let disposed = false;
+		let queue = Promise.resolve();
+		const enqueue = (audio) => {
+			const run = queue.then(() => transcriber.transcribe(audio));
+			queue = run.catch(() => void 0);
+			return run;
+		};
+		let live;
+		async function* liveLoop(session) {
+			let last = {
+				committed: "",
+				nonCommitted: ""
+			};
+			try {
+				while (true) {
+					if (!session.stopped && session.fresh < TICK_SAMPLES) {
+						await new Promise((resolve) => {
+							session.wake = resolve;
+						});
+						continue;
+					}
+					const final = session.stopped;
+					session.fresh = 0;
+					const audio = concat(session.chunks, session.length);
+					const segment = analyzeSegment(audio, {
+						sampleRate: SPEECH_SAMPLE_RATE,
+						maxSegmentSeconds: MAX_SEGMENT_SECONDS
+					});
+					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);
+					let committed = last.committed;
+					if (final || segment.shouldFinalize) {
+						if (text) committed = committed ? `${committed} ${text}` : text;
+						text = "";
+						session.chunks = [];
+						session.length = 0;
+					}
+					if (committed !== last.committed || text !== last.nonCommitted) {
+						last = {
+							committed,
+							nonCommitted: text
+						};
+						yield last;
+					}
+					if (final) return;
+				}
+			} finally {
+				if (live === session) live = void 0;
+			}
+		}
+		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 (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");
+				live = {
+					chunks: [],
+					length: 0,
+					fresh: 0,
+					stopped: false,
+					wake: () => {}
+				};
+				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");
+				live.chunks.push(samples.slice());
+				live.length += samples.length;
+				live.fresh += samples.length;
+				if (live.fresh >= TICK_SAMPLES) live.wake();
+			},
+			streamStop() {
+				if (!live) return;
+				live.stopped = true;
+				live.wake();
+			},
+			dispose() {
+				disposed = true;
+				if (live) {
+					live.chunks = [];
+					live.length = 0;
+					live.stopped = true;
+					live.wake();
+				}
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+/** Joins the chunks into one array of `length` samples. */
+function concat(chunks, length) {
+	const out = new Float32Array(length);
+	let at = 0;
+	for (const c of chunks) {
+		out.set(c, at);
+		at += c.length;
+	}
+	return out;
+}
+/** 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;
+}
+//#endregion
+//#region src/zoo/yolo26/pipeline.ts
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+function scanCells(levels, numClasses, confThreshold) {
+	const logitThreshold = Math.log(confThreshold / (1 - confThreshold));
+	const hits = [];
+	levels.forEach(({ data, h, w, stride }, levelIdx) => {
+		const hw = h * w;
+		for (let i = 0; i < hw; i++) {
+			let bestLogit = -Infinity;
+			let bestClass = 0;
+			for (let c = 0; c < numClasses; c++) {
+				const v = data[(4 + c) * hw + i];
+				if (v > bestLogit) {
+					bestLogit = v;
+					bestClass = c;
+				}
+			}
+			if (bestLogit < logitThreshold) continue;
+			const score = sigmoid(bestLogit);
+			const ax = i % w + .5;
+			const ay = Math.floor(i / w) + .5;
+			const l = data[i];
+			const t = data[hw + i];
+			const r = data[2 * hw + i];
+			const b = data[3 * hw + i];
+			hits.push({
+				levelIdx,
+				cell: i,
+				det: {
+					x1: (ax - l) * stride,
+					y1: (ay - t) * stride,
+					x2: (ax + r) * stride,
+					y2: (ay + b) * stride,
+					score,
+					classId: bestClass,
+					label: COCO_NAMES[bestClass] ?? `cls${bestClass}`
+				}
+			});
+		}
+	});
+	hits.sort((a, b) => b.det.score - a.det.score);
+	return hits;
+}
+function decodeDetections(levels, opts = {}) {
+	const { numClasses = 80, confThreshold = .3, maxDet = 300 } = opts;
+	return scanCells(levels, numClasses, confThreshold).slice(0, maxDet).map((h) => h.det);
+}
+function decodeSegmentations(levels, proto, opts = {}) {
+	const { numClasses = 80, numMasks = 32, confThreshold = .3, maxDet = 300, inputSize = 640 } = opts;
+	const protoStride = inputSize / proto.w;
+	const phw = proto.h * proto.w;
+	return scanCells(levels, numClasses, confThreshold).slice(0, maxDet).map(({ levelIdx, cell, det }) => {
+		const { data, h, w } = levels[levelIdx];
+		const hw = h * w;
+		const coeffs = new Float32Array(numMasks);
+		for (let c = 0; c < numMasks; c++) coeffs[c] = data[(4 + numClasses + c) * hw + cell];
+		const px1 = Math.min(proto.w, Math.max(0, Math.floor(det.x1 / protoStride)));
+		const py1 = Math.min(proto.h, Math.max(0, Math.floor(det.y1 / protoStride)));
+		const px2 = Math.min(proto.w, Math.max(px1, Math.ceil(det.x2 / protoStride)));
+		const py2 = Math.min(proto.h, Math.max(py1, Math.ceil(det.y2 / protoStride)));
+		const maskW = px2 - px1;
+		const maskH = py2 - py1;
+		const mask = new Uint8Array(maskW * maskH);
+		for (let y = 0; y < maskH; y++) for (let x = 0; x < maskW; x++) {
+			const pi = (py1 + y) * proto.w + (px1 + x);
+			let v = 0;
+			for (let c = 0; c < numMasks; c++) v += coeffs[c] * proto.data[c * phw + pi];
+			mask[y * maskW + x] = Math.round(255 * sigmoid(v));
+		}
+		return {
+			...det,
+			mask,
+			maskX: px1,
+			maskY: py1,
+			maskW,
+			maskH
+		};
+	});
+}
+function decodePoses(levels, opts = {}) {
+	const { numClasses = 1, numKeypoints = 17, confThreshold = .3, maxDet = 300 } = opts;
+	return scanCells(levels, numClasses, confThreshold).slice(0, maxDet).map(({ levelIdx, cell, det }) => {
+		const { data, h, w, stride } = levels[levelIdx];
+		const hw = h * w;
+		const ax = cell % w + .5;
+		const ay = Math.floor(cell / w) + .5;
+		const kpts = [];
+		for (let k = 0; k < numKeypoints; k++) {
+			const o = (4 + numClasses + 3 * k) * hw + cell;
+			kpts.push({
+				x: (data[o] + ax) * stride,
+				y: (data[o + hw] + ay) * stride,
+				v: sigmoid(data[o + 2 * hw])
+			});
+		}
+		return {
+			...det,
+			kpts
+		};
+	});
+}
+/** The 17 COCO body landmarks, in model output order. */
+const COCO_LANDMARKS = [
+	"nose",
+	"leftEye",
+	"rightEye",
+	"leftEar",
+	"rightEar",
+	"leftShoulder",
+	"rightShoulder",
+	"leftElbow",
+	"rightElbow",
+	"leftWrist",
+	"rightWrist",
+	"leftHip",
+	"rightHip",
+	"leftKnee",
+	"rightKnee",
+	"leftAnkle",
+	"rightAnkle"
+];
+/** Limbs to draw between COCO keypoints; ear-to-shoulder is left out because it
+*  cuts across the face. */
+const COCO_SKELETON = [
+	[15, 13],
+	[13, 11],
+	[16, 14],
+	[14, 12],
+	[11, 12],
+	[5, 11],
+	[6, 12],
+	[5, 6],
+	[5, 7],
+	[6, 8],
+	[7, 9],
+	[8, 10],
+	[1, 2],
+	[0, 1],
+	[0, 2],
+	[1, 3],
+	[2, 4]
+];
+const COCO_NAMES = [
+	"person",
+	"bicycle",
+	"car",
+	"motorcycle",
+	"airplane",
+	"bus",
+	"train",
+	"truck",
+	"boat",
+	"traffic light",
+	"fire hydrant",
+	"stop sign",
+	"parking meter",
+	"bench",
+	"bird",
+	"cat",
+	"dog",
+	"horse",
+	"sheep",
+	"cow",
+	"elephant",
+	"bear",
+	"zebra",
+	"giraffe",
+	"backpack",
+	"umbrella",
+	"handbag",
+	"tie",
+	"suitcase",
+	"frisbee",
+	"skis",
+	"snowboard",
+	"sports ball",
+	"kite",
+	"baseball bat",
+	"baseball glove",
+	"skateboard",
+	"surfboard",
+	"tennis racket",
+	"bottle",
+	"wine glass",
+	"cup",
+	"fork",
+	"knife",
+	"spoon",
+	"bowl",
+	"banana",
+	"apple",
+	"sandwich",
+	"orange",
+	"broccoli",
+	"carrot",
+	"hot dog",
+	"pizza",
+	"donut",
+	"cake",
+	"chair",
+	"couch",
+	"potted plant",
+	"bed",
+	"dining table",
+	"toilet",
+	"tv",
+	"laptop",
+	"mouse",
+	"remote",
+	"keyboard",
+	"cell phone",
+	"microwave",
+	"oven",
+	"toaster",
+	"sink",
+	"refrigerator",
+	"book",
+	"clock",
+	"vase",
+	"scissors",
+	"teddy bear",
+	"hair drier",
+	"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. */
+function decodeBox(tuple, format) {
+	const [a, b, c, d] = tuple;
+	switch (format) {
+		case "xyxy": return {
+			format: "xyxy",
+			xmin: a,
+			ymin: b,
+			xmax: c,
+			ymax: d
+		};
+		case "xywh": return {
+			format: "xywh",
+			xmin: a,
+			ymin: b,
+			w: c,
+			h: d
+		};
+		case "cxcywh": return {
+			format: "cxcywh",
+			cx: a,
+			cy: b,
+			w: c,
+			h: d
+		};
+		default: throw new Error(`unknown box format ${String(format)}`);
+	}
+}
+/** Maps a box from model-input coordinates to original-image coordinates. */
+function scaleBox(box, options) {
+	const { scaleX, scaleY } = resizeTransform(options);
+	switch (box.format) {
+		case "xyxy": {
+			const min = scalePoint({
+				x: box.xmin,
+				y: box.ymin
+			}, options);
+			const max = scalePoint({
+				x: box.xmax,
+				y: box.ymax
+			}, options);
+			return {
+				format: "xyxy",
+				xmin: min.x,
+				ymin: min.y,
+				xmax: max.x,
+				ymax: max.y
+			};
+		}
+		case "xywh": {
+			const min = scalePoint({
+				x: box.xmin,
+				y: box.ymin
+			}, options);
+			return {
+				format: "xywh",
+				xmin: min.x,
+				ymin: min.y,
+				w: box.w / scaleX,
+				h: box.h / scaleY
+			};
+		}
+		case "cxcywh": {
+			const center = scalePoint({
+				x: box.cx,
+				y: box.cy
+			}, options);
+			return {
+				format: "cxcywh",
+				cx: center.x,
+				cy: center.y,
+				w: box.w / scaleX,
+				h: box.h / scaleY
+			};
+		}
+	}
+}
+//#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. */
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+*  Needs a device with `shader-f16`. */
+async function createObjectDetector(config = {}, opts = {}) {
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.objectDetection.YOLO26.DEFAULT.modelPath, variant, inputSize: size, resizeMode = "letterbox" } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `yolo26-v1/${path}`)
+		});
+		throwIfAborted(opts.signal);
+		const detector = scope.track(await createDetector$1(sd, {
+			task: "detect",
+			variant,
+			inputSize: size,
+			onProgress: opts.onProgress
+		}));
+		const { inputSize, numClasses } = detector;
+		const labels = numClasses === COCO_NAMES.length ? COCO_NAMES : Array.from({ length: numClasses }, (_, i) => `class ${i}`);
+		const preprocessor = createImagePreprocessor({ resizeMode }, {
+			width: inputSize,
+			height: inputSize
+		});
+		const pixels = new Float32Array(3 * inputSize * inputSize);
+		let disposed = false;
+		let queue = Promise.resolve();
+		return {
+			labels,
+			async detectObjects(image, options = {}) {
+				if (disposed) throw new Error("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 scale = preprocessor.scaleOptions(image);
+				return decodeDetections(levels, {
+					numClasses,
+					confThreshold: confidenceThreshold,
+					maxDet: maxDetections
+				}).map((d) => {
+					const box = scaleBox(decodeBox([
+						d.x1,
+						d.y1,
+						d.x2,
+						d.y2
+					], "xyxy"), scale);
+					return {
+						label: labels[d.classId],
+						classId: d.classId,
+						confidence: d.score,
+						box: {
+							format: "xyxy",
+							xmin: clamp$2(box.xmin, 0, image.width),
+							ymin: clamp$2(box.ymin, 0, image.height),
+							xmax: clamp$2(box.xmax, 0, image.width),
+							ymax: clamp$2(box.ymax, 0, image.height)
+						}
+					};
+				});
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+const clamp$2 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+//#endregion
+//#region src/zoo/tasks/cv/instanceSegmentation.ts
+/** Instance segmentation task: an image in, the objects in it out, each
+*  with a box and a pixel mask. Runs YOLO26 segment on the initRunntime() device. */
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+*  Needs a device with `shader-f16`. */
+async function createInstanceSegmenter(config = {}, opts = {}) {
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.instanceSegmentation.YOLO26_SEG.DEFAULT.modelPath, variant, inputSize: size, resizeMode = "letterbox" } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `yolo26-seg-v1/${path}`)
+		});
+		throwIfAborted(opts.signal);
+		const detector = scope.track(await createDetector$1(sd, {
+			task: "segment",
+			variant,
+			inputSize: size,
+			onProgress: opts.onProgress
+		}));
+		const { inputSize, numClasses } = detector;
+		const labels = numClasses === COCO_NAMES.length ? COCO_NAMES : Array.from({ length: numClasses }, (_, i) => `class ${i}`);
+		const preprocessor = createImagePreprocessor({ resizeMode }, {
+			width: inputSize,
+			height: inputSize
+		});
+		const pixels = new Float32Array(3 * inputSize * inputSize);
+		let disposed = false;
+		let queue = Promise.resolve();
+		return {
+			labels,
+			async segmentInstances(image, options = {}) {
+				if (disposed) throw new Error("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 scale = preprocessor.scaleOptions(image);
+				const toInput = resizeTransform(scale);
+				const protoStride = inputSize / proto.w;
+				return decodeSegmentations(levels, proto, {
+					numClasses,
+					numMasks: 32,
+					confThreshold: confidenceThreshold,
+					maxDet: maxDetections,
+					inputSize
+				}).map((d) => {
+					const raw = scaleBox(decodeBox([
+						d.x1,
+						d.y1,
+						d.x2,
+						d.y2
+					], "xyxy"), scale);
+					const box = {
+						format: "xyxy",
+						xmin: clamp$1(raw.xmin, 0, image.width),
+						ymin: clamp$1(raw.ymin, 0, image.height),
+						xmax: clamp$1(raw.xmax, 0, image.width),
+						ymax: clamp$1(raw.ymax, 0, image.height)
+					};
+					const cell = (v, axis) => axis === "x" ? (v * toInput.scaleX + toInput.offsetX) / protoStride - d.maskX : (v * toInput.scaleY + toInput.offsetY) / protoStride - d.maskY;
+					const mask = resampleMask(d.mask, d.maskW, d.maskH, cell(box.xmin, "x"), cell(box.ymin, "y"), cell(box.xmax, "x"), cell(box.ymax, "y"));
+					return {
+						label: labels[d.classId],
+						classId: d.classId,
+						confidence: d.score,
+						box,
+						mask
+					};
+				});
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+const clamp$1 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** Bilinear resample of the cell window [u0,u1)×[v0,v1) of a `w`×`h`
+*  coverage map into a gray image of the same cell count. */
+function resampleMask(src, w, h, u0, v0, u1, v1) {
+	const width = Math.max(1, Math.round(u1 - u0));
+	const height = Math.max(1, Math.round(v1 - v0));
+	const data = new Uint8Array(width * height);
+	const at = (x, y) => src[clamp$1(y, 0, h - 1) * w + clamp$1(x, 0, w - 1)];
+	const du = (u1 - u0) / width;
+	const dv = (v1 - v0) / height;
+	for (let j = 0; j < height; j++) {
+		const v = v0 + (j + .5) * dv - .5;
+		const y = Math.floor(v);
+		const fy = v - y;
+		for (let i = 0; i < width; i++) {
+			const u = u0 + (i + .5) * du - .5;
+			const x = Math.floor(u);
+			const fx = u - x;
+			const top = at(x, y) * (1 - fx) + at(x + 1, y) * fx;
+			const bottom = at(x, y + 1) * (1 - fx) + at(x + 1, y + 1) * fx;
+			data[j * width + i] = Math.round(top * (1 - fy) + bottom * fy);
+		}
+	}
+	return {
+		data,
+		width,
+		height,
+		format: "gray",
+		layout: "hwc"
+	};
+}
+//#endregion
+//#region src/zoo/tasks/cv/keypointDetection.ts
+/** Keypoint detection task: an image in, the people in it out, each with a
+*  box and 17 COCO landmarks. Runs YOLO26 pose on the initRunntime() device. */
+/** Loads the checkpoint, warms the GPU path once, and returns the runner.
+*  Needs a device with `shader-f16`. */
+async function createKeypointDetector(config = {}, opts = {}) {
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.keypointDetection.YOLO26_POSE.DEFAULT.modelPath, variant, inputSize: size, resizeMode = "letterbox" } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `yolo26-pose-v1/${path}`)
+		});
+		throwIfAborted(opts.signal);
+		const detector = scope.track(await createDetector$1(sd, {
+			task: "pose",
+			variant,
+			inputSize: size,
+			onProgress: opts.onProgress
+		}));
+		const { inputSize, numClasses } = detector;
+		const preprocessor = createImagePreprocessor({ resizeMode }, {
+			width: inputSize,
+			height: inputSize
+		});
+		const pixels = new Float32Array(3 * inputSize * inputSize);
+		let disposed = false;
+		let queue = Promise.resolve();
+		return {
+			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");
+				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 scale = preprocessor.scaleOptions(image);
+				return decodePoses(levels, {
+					numClasses,
+					numKeypoints: 17,
+					confThreshold: confidenceThreshold,
+					maxDet: maxDetections
+				}).map((p) => {
+					const box = scaleBox(decodeBox([
+						p.x1,
+						p.y1,
+						p.x2,
+						p.y2
+					], "xyxy"), scale);
+					const landmarks = {};
+					p.kpts.forEach((k, i) => {
+						landmarks[COCO_LANDMARKS[i]] = {
+							...scalePoint(k, scale),
+							confidence: k.v
+						};
+					});
+					return {
+						box: {
+							format: "xyxy",
+							xmin: clamp(box.xmin, 0, image.width),
+							ymin: clamp(box.ymin, 0, image.height),
+							xmax: clamp(box.xmax, 0, image.width),
+							ymax: clamp(box.ymax, 0, image.height)
+						},
+						confidence: p.score,
+						landmarks
+					};
+				});
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+//#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'] } })");
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.depthEstimation.DEPTHART.DEFAULT.modelPath, variant, resizeMode = "stretch" } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `depthart-v1/${path}`)
+		});
+		throwIfAborted(opts.signal);
+		const estimator = scope.track(await createEstimator(sd, {
+			variant,
+			onProgress: opts.onProgress
+		}));
+		const { inputSize } = estimator;
+		const { mean, std } = DEPTHART_CONFIGS[estimator.variant];
+		const preprocessor = createImagePreprocessor({
+			resizeMode,
+			normalizeOpts: {
+				alpha: std.map((s) => 1 / (255 * s)),
+				beta: mean.map((m, c) => -m / std[c])
+			}
+		}, {
+			width: inputSize,
+			height: inputSize
+		});
+		const pixels = new Float32Array(3 * inputSize * inputSize);
+		let disposed = false;
+		let queue = Promise.resolve();
+		return {
+			inputSize,
+			async estimateDepth(image) {
+				if (disposed) throw new Error("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
+				};
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+//#endregion
+//#region src/zoo/mobilenetv4/labels.ts
+/** The 1000 ImageNet-1k class names, in class index order, as the Hub
+*  config's `id2label` spells them. */
+const IMAGENET1K_LABELS = [
+	"tench, Tinca tinca",
+	"goldfish, Carassius auratus",
+	"great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias",
+	"tiger shark, Galeocerdo cuvieri",
+	"hammerhead, hammerhead shark",
+	"electric ray, crampfish, numbfish, torpedo",
+	"stingray",
+	"cock",
+	"hen",
+	"ostrich, Struthio camelus",
+	"brambling, Fringilla montifringilla",
+	"goldfinch, Carduelis carduelis",
+	"house finch, linnet, Carpodacus mexicanus",
+	"junco, snowbird",
+	"indigo bunting, indigo finch, indigo bird, Passerina cyanea",
+	"robin, American robin, Turdus migratorius",
+	"bulbul",
+	"jay",
+	"magpie",
+	"chickadee",
+	"water ouzel, dipper",
+	"kite",
+	"bald eagle, American eagle, Haliaeetus leucocephalus",
+	"vulture",
+	"great grey owl, great gray owl, Strix nebulosa",
+	"European fire salamander, Salamandra salamandra",
+	"common newt, Triturus vulgaris",
+	"eft",
+	"spotted salamander, Ambystoma maculatum",
+	"axolotl, mud puppy, Ambystoma mexicanum",
+	"bullfrog, Rana catesbeiana",
+	"tree frog, tree-frog",
+	"tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui",
+	"loggerhead, loggerhead turtle, Caretta caretta",
+	"leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea",
+	"mud turtle",
+	"terrapin",
+	"box turtle, box tortoise",
+	"banded gecko",
+	"common iguana, iguana, Iguana iguana",
+	"American chameleon, anole, Anolis carolinensis",
+	"whiptail, whiptail lizard",
+	"agama",
+	"frilled lizard, Chlamydosaurus kingi",
+	"alligator lizard",
+	"Gila monster, Heloderma suspectum",
+	"green lizard, Lacerta viridis",
+	"African chameleon, Chamaeleo chamaeleon",
+	"Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis",
+	"African crocodile, Nile crocodile, Crocodylus niloticus",
+	"American alligator, Alligator mississipiensis",
+	"triceratops",
+	"thunder snake, worm snake, Carphophis amoenus",
+	"ringneck snake, ring-necked snake, ring snake",
+	"hognose snake, puff adder, sand viper",
+	"green snake, grass snake",
+	"king snake, kingsnake",
+	"garter snake, grass snake",
+	"water snake",
+	"vine snake",
+	"night snake, Hypsiglena torquata",
+	"boa constrictor, Constrictor constrictor",
+	"rock python, rock snake, Python sebae",
+	"Indian cobra, Naja naja",
+	"green mamba",
+	"sea snake",
+	"horned viper, cerastes, sand viper, horned asp, Cerastes cornutus",
+	"diamondback, diamondback rattlesnake, Crotalus adamanteus",
+	"sidewinder, horned rattlesnake, Crotalus cerastes",
+	"trilobite",
+	"harvestman, daddy longlegs, Phalangium opilio",
+	"scorpion",
+	"black and gold garden spider, Argiope aurantia",
+	"barn spider, Araneus cavaticus",
+	"garden spider, Aranea diademata",
+	"black widow, Latrodectus mactans",
+	"tarantula",
+	"wolf spider, hunting spider",
+	"tick",
+	"centipede",
+	"black grouse",
+	"ptarmigan",
+	"ruffed grouse, partridge, Bonasa umbellus",
+	"prairie chicken, prairie grouse, prairie fowl",
+	"peacock",
+	"quail",
+	"partridge",
+	"African grey, African gray, Psittacus erithacus",
+	"macaw",
+	"sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita",
+	"lorikeet",
+	"coucal",
+	"bee eater",
+	"hornbill",
+	"hummingbird",
+	"jacamar",
+	"toucan",
+	"drake",
+	"red-breasted merganser, Mergus serrator",
+	"goose",
+	"black swan, Cygnus atratus",
+	"tusker",
+	"echidna, spiny anteater, anteater",
+	"platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus",
+	"wallaby, brush kangaroo",
+	"koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus",
+	"wombat",
+	"jellyfish",
+	"sea anemone, anemone",
+	"brain coral",
+	"flatworm, platyhelminth",
+	"nematode, nematode worm, roundworm",
+	"conch",
+	"snail",
+	"slug",
+	"sea slug, nudibranch",
+	"chiton, coat-of-mail shell, sea cradle, polyplacophore",
+	"chambered nautilus, pearly nautilus, nautilus",
+	"Dungeness crab, Cancer magister",
+	"rock crab, Cancer irroratus",
+	"fiddler crab",
+	"king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica",
+	"American lobster, Northern lobster, Maine lobster, Homarus americanus",
+	"spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish",
+	"crayfish, crawfish, crawdad, crawdaddy",
+	"hermit crab",
+	"isopod",
+	"white stork, Ciconia ciconia",
+	"black stork, Ciconia nigra",
+	"spoonbill",
+	"flamingo",
+	"little blue heron, Egretta caerulea",
+	"American egret, great white heron, Egretta albus",
+	"bittern",
+	"crane",
+	"limpkin, Aramus pictus",
+	"European gallinule, Porphyrio porphyrio",
+	"American coot, marsh hen, mud hen, water hen, Fulica americana",
+	"bustard",
+	"ruddy turnstone, Arenaria interpres",
+	"red-backed sandpiper, dunlin, Erolia alpina",
+	"redshank, Tringa totanus",
+	"dowitcher",
+	"oystercatcher, oyster catcher",
+	"pelican",
+	"king penguin, Aptenodytes patagonica",
+	"albatross, mollymawk",
+	"grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus",
+	"killer whale, killer, orca, grampus, sea wolf, Orcinus orca",
+	"dugong, Dugong dugon",
+	"sea lion",
+	"Chihuahua",
+	"Japanese spaniel",
+	"Maltese dog, Maltese terrier, Maltese",
+	"Pekinese, Pekingese, Peke",
+	"Shih-Tzu",
+	"Blenheim spaniel",
+	"papillon",
+	"toy terrier",
+	"Rhodesian ridgeback",
+	"Afghan hound, Afghan",
+	"basset, basset hound",
+	"beagle",
+	"bloodhound, sleuthhound",
+	"bluetick",
+	"black-and-tan coonhound",
+	"Walker hound, Walker foxhound",
+	"English foxhound",
+	"redbone",
+	"borzoi, Russian wolfhound",
+	"Irish wolfhound",
+	"Italian greyhound",
+	"whippet",
+	"Ibizan hound, Ibizan Podenco",
+	"Norwegian elkhound, elkhound",
+	"otterhound, otter hound",
+	"Saluki, gazelle hound",
+	"Scottish deerhound, deerhound",
+	"Weimaraner",
+	"Staffordshire bullterrier, Staffordshire bull terrier",
+	"American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier",
+	"Bedlington terrier",
+	"Border terrier",
+	"Kerry blue terrier",
+	"Irish terrier",
+	"Norfolk terrier",
+	"Norwich terrier",
+	"Yorkshire terrier",
+	"wire-haired fox terrier",
+	"Lakeland terrier",
+	"Sealyham terrier, Sealyham",
+	"Airedale, Airedale terrier",
+	"cairn, cairn terrier",
+	"Australian terrier",
+	"Dandie Dinmont, Dandie Dinmont terrier",
+	"Boston bull, Boston terrier",
+	"miniature schnauzer",
+	"giant schnauzer",
+	"standard schnauzer",
+	"Scotch terrier, Scottish terrier, Scottie",
+	"Tibetan terrier, chrysanthemum dog",
+	"silky terrier, Sydney silky",
+	"soft-coated wheaten terrier",
+	"West Highland white terrier",
+	"Lhasa, Lhasa apso",
+	"flat-coated retriever",
+	"curly-coated retriever",
+	"golden retriever",
+	"Labrador retriever",
+	"Chesapeake Bay retriever",
+	"German short-haired pointer",
+	"vizsla, Hungarian pointer",
+	"English setter",
+	"Irish setter, red setter",
+	"Gordon setter",
+	"Brittany spaniel",
+	"clumber, clumber spaniel",
+	"English springer, English springer spaniel",
+	"Welsh springer spaniel",
+	"cocker spaniel, English cocker spaniel, cocker",
+	"Sussex spaniel",
+	"Irish water spaniel",
+	"kuvasz",
+	"schipperke",
+	"groenendael",
+	"malinois",
+	"briard",
+	"kelpie",
+	"komondor",
+	"Old English sheepdog, bobtail",
+	"Shetland sheepdog, Shetland sheep dog, Shetland",
+	"collie",
+	"Border collie",
+	"Bouvier des Flandres, Bouviers des Flandres",
+	"Rottweiler",
+	"German shepherd, German shepherd dog, German police dog, alsatian",
+	"Doberman, Doberman pinscher",
+	"miniature pinscher",
+	"Greater Swiss Mountain dog",
+	"Bernese mountain dog",
+	"Appenzeller",
+	"EntleBucher",
+	"boxer",
+	"bull mastiff",
+	"Tibetan mastiff",
+	"French bulldog",
+	"Great Dane",
+	"Saint Bernard, St Bernard",
+	"Eskimo dog, husky",
+	"malamute, malemute, Alaskan malamute",
+	"Siberian husky",
+	"dalmatian, coach dog, carriage dog",
+	"affenpinscher, monkey pinscher, monkey dog",
+	"basenji",
+	"pug, pug-dog",
+	"Leonberg",
+	"Newfoundland, Newfoundland dog",
+	"Great Pyrenees",
+	"Samoyed, Samoyede",
+	"Pomeranian",
+	"chow, chow chow",
+	"keeshond",
+	"Brabancon griffon",
+	"Pembroke, Pembroke Welsh corgi",
+	"Cardigan, Cardigan Welsh corgi",
+	"toy poodle",
+	"miniature poodle",
+	"standard poodle",
+	"Mexican hairless",
+	"timber wolf, grey wolf, gray wolf, Canis lupus",
+	"white wolf, Arctic wolf, Canis lupus tundrarum",
+	"red wolf, maned wolf, Canis rufus, Canis niger",
+	"coyote, prairie wolf, brush wolf, Canis latrans",
+	"dingo, warrigal, warragal, Canis dingo",
+	"dhole, Cuon alpinus",
+	"African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus",
+	"hyena, hyaena",
+	"red fox, Vulpes vulpes",
+	"kit fox, Vulpes macrotis",
+	"Arctic fox, white fox, Alopex lagopus",
+	"grey fox, gray fox, Urocyon cinereoargenteus",
+	"tabby, tabby cat",
+	"tiger cat",
+	"Persian cat",
+	"Siamese cat, Siamese",
+	"Egyptian cat",
+	"cougar, puma, catamount, mountain lion, painter, panther, Felis concolor",
+	"lynx, catamount",
+	"leopard, Panthera pardus",
+	"snow leopard, ounce, Panthera uncia",
+	"jaguar, panther, Panthera onca, Felis onca",
+	"lion, king of beasts, Panthera leo",
+	"tiger, Panthera tigris",
+	"cheetah, chetah, Acinonyx jubatus",
+	"brown bear, bruin, Ursus arctos",
+	"American black bear, black bear, Ursus americanus, Euarctos americanus",
+	"ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus",
+	"sloth bear, Melursus ursinus, Ursus ursinus",
+	"mongoose",
+	"meerkat, mierkat",
+	"tiger beetle",
+	"ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle",
+	"ground beetle, carabid beetle",
+	"long-horned beetle, longicorn, longicorn beetle",
+	"leaf beetle, chrysomelid",
+	"dung beetle",
+	"rhinoceros beetle",
+	"weevil",
+	"fly",
+	"bee",
+	"ant, emmet, pismire",
+	"grasshopper, hopper",
+	"cricket",
+	"walking stick, walkingstick, stick insect",
+	"cockroach, roach",
+	"mantis, mantid",
+	"cicada, cicala",
+	"leafhopper",
+	"lacewing, lacewing fly",
+	"dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk",
+	"damselfly",
+	"admiral",
+	"ringlet, ringlet butterfly",
+	"monarch, monarch butterfly, milkweed butterfly, Danaus plexippus",
+	"cabbage butterfly",
+	"sulphur butterfly, sulfur butterfly",
+	"lycaenid, lycaenid butterfly",
+	"starfish, sea star",
+	"sea urchin",
+	"sea cucumber, holothurian",
+	"wood rabbit, cottontail, cottontail rabbit",
+	"hare",
+	"Angora, Angora rabbit",
+	"hamster",
+	"porcupine, hedgehog",
+	"fox squirrel, eastern fox squirrel, Sciurus niger",
+	"marmot",
+	"beaver",
+	"guinea pig, Cavia cobaya",
+	"sorrel",
+	"zebra",
+	"hog, pig, grunter, squealer, Sus scrofa",
+	"wild boar, boar, Sus scrofa",
+	"warthog",
+	"hippopotamus, hippo, river horse, Hippopotamus amphibius",
+	"ox",
+	"water buffalo, water ox, Asiatic buffalo, Bubalus bubalis",
+	"bison",
+	"ram, tup",
+	"bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis",
+	"ibex, Capra ibex",
+	"hartebeest",
+	"impala, Aepyceros melampus",
+	"gazelle",
+	"Arabian camel, dromedary, Camelus dromedarius",
+	"llama",
+	"weasel",
+	"mink",
+	"polecat, fitch, foulmart, foumart, Mustela putorius",
+	"black-footed ferret, ferret, Mustela nigripes",
+	"otter",
+	"skunk, polecat, wood pussy",
+	"badger",
+	"armadillo",
+	"three-toed sloth, ai, Bradypus tridactylus",
+	"orangutan, orang, orangutang, Pongo pygmaeus",
+	"gorilla, Gorilla gorilla",
+	"chimpanzee, chimp, Pan troglodytes",
+	"gibbon, Hylobates lar",
+	"siamang, Hylobates syndactylus, Symphalangus syndactylus",
+	"guenon, guenon monkey",
+	"patas, hussar monkey, Erythrocebus patas",
+	"baboon",
+	"macaque",
+	"langur",
+	"colobus, colobus monkey",
+	"proboscis monkey, Nasalis larvatus",
+	"marmoset",
+	"capuchin, ringtail, Cebus capucinus",
+	"howler monkey, howler",
+	"titi, titi monkey",
+	"spider monkey, Ateles geoffroyi",
+	"squirrel monkey, Saimiri sciureus",
+	"Madagascar cat, ring-tailed lemur, Lemur catta",
+	"indri, indris, Indri indri, Indri brevicaudatus",
+	"Indian elephant, Elephas maximus",
+	"African elephant, Loxodonta africana",
+	"lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens",
+	"giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca",
+	"barracouta, snoek",
+	"eel",
+	"coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch",
+	"rock beauty, Holocanthus tricolor",
+	"anemone fish",
+	"sturgeon",
+	"gar, garfish, garpike, billfish, Lepisosteus osseus",
+	"lionfish",
+	"puffer, pufferfish, blowfish, globefish",
+	"abacus",
+	"abaya",
+	"academic gown, academic robe, judge's robe",
+	"accordion, piano accordion, squeeze box",
+	"acoustic guitar",
+	"aircraft carrier, carrier, flattop, attack aircraft carrier",
+	"airliner",
+	"airship, dirigible",
+	"altar",
+	"ambulance",
+	"amphibian, amphibious vehicle",
+	"analog clock",
+	"apiary, bee house",
+	"apron",
+	"ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin",
+	"assault rifle, assault gun",
+	"backpack, back pack, knapsack, packsack, rucksack, haversack",
+	"bakery, bakeshop, bakehouse",
+	"balance beam, beam",
+	"balloon",
+	"ballpoint, ballpoint pen, ballpen, Biro",
+	"Band Aid",
+	"banjo",
+	"bannister, banister, balustrade, balusters, handrail",
+	"barbell",
+	"barber chair",
+	"barbershop",
+	"barn",
+	"barometer",
+	"barrel, cask",
+	"barrow, garden cart, lawn cart, wheelbarrow",
+	"baseball",
+	"basketball",
+	"bassinet",
+	"bassoon",
+	"bathing cap, swimming cap",
+	"bath towel",
+	"bathtub, bathing tub, bath, tub",
+	"beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon",
+	"beacon, lighthouse, beacon light, pharos",
+	"beaker",
+	"bearskin, busby, shako",
+	"beer bottle",
+	"beer glass",
+	"bell cote, bell cot",
+	"bib",
+	"bicycle-built-for-two, tandem bicycle, tandem",
+	"bikini, two-piece",
+	"binder, ring-binder",
+	"binoculars, field glasses, opera glasses",
+	"birdhouse",
+	"boathouse",
+	"bobsled, bobsleigh, bob",
+	"bolo tie, bolo, bola tie, bola",
+	"bonnet, poke bonnet",
+	"bookcase",
+	"bookshop, bookstore, bookstall",
+	"bottlecap",
+	"bow",
+	"bow tie, bow-tie, bowtie",
+	"brass, memorial tablet, plaque",
+	"brassiere, bra, bandeau",
+	"breakwater, groin, groyne, mole, bulwark, seawall, jetty",
+	"breastplate, aegis, egis",
+	"broom",
+	"bucket, pail",
+	"buckle",
+	"bulletproof vest",
+	"bullet train, bullet",
+	"butcher shop, meat market",
+	"cab, hack, taxi, taxicab",
+	"caldron, cauldron",
+	"candle, taper, wax light",
+	"cannon",
+	"canoe",
+	"can opener, tin opener",
+	"cardigan",
+	"car mirror",
+	"carousel, carrousel, merry-go-round, roundabout, whirligig",
+	"carpenter's kit, tool kit",
+	"carton",
+	"car wheel",
+	"cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM",
+	"cassette",
+	"cassette player",
+	"castle",
+	"catamaran",
+	"CD player",
+	"cello, violoncello",
+	"cellular telephone, cellular phone, cellphone, cell, mobile phone",
+	"chain",
+	"chainlink fence",
+	"chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour",
+	"chain saw, chainsaw",
+	"chest",
+	"chiffonier, commode",
+	"chime, bell, gong",
+	"china cabinet, china closet",
+	"Christmas stocking",
+	"church, church building",
+	"cinema, movie theater, movie theatre, movie house, picture palace",
+	"cleaver, meat cleaver, chopper",
+	"cliff dwelling",
+	"cloak",
+	"clog, geta, patten, sabot",
+	"cocktail shaker",
+	"coffee mug",
+	"coffeepot",
+	"coil, spiral, volute, whorl, helix",
+	"combination lock",
+	"computer keyboard, keypad",
+	"confectionery, confectionary, candy store",
+	"container ship, containership, container vessel",
+	"convertible",
+	"corkscrew, bottle screw",
+	"cornet, horn, trumpet, trump",
+	"cowboy boot",
+	"cowboy hat, ten-gallon hat",
+	"cradle",
+	"crane",
+	"crash helmet",
+	"crate",
+	"crib, cot",
+	"Crock Pot",
+	"croquet ball",
+	"crutch",
+	"cuirass",
+	"dam, dike, dyke",
+	"desk",
+	"desktop computer",
+	"dial telephone, dial phone",
+	"diaper, nappy, napkin",
+	"digital clock",
+	"digital watch",
+	"dining table, board",
+	"dishrag, dishcloth",
+	"dishwasher, dish washer, dishwashing machine",
+	"disk brake, disc brake",
+	"dock, dockage, docking facility",
+	"dogsled, dog sled, dog sleigh",
+	"dome",
+	"doormat, welcome mat",
+	"drilling platform, offshore rig",
+	"drum, membranophone, tympan",
+	"drumstick",
+	"dumbbell",
+	"Dutch oven",
+	"electric fan, blower",
+	"electric guitar",
+	"electric locomotive",
+	"entertainment center",
+	"envelope",
+	"espresso maker",
+	"face powder",
+	"feather boa, boa",
+	"file, file cabinet, filing cabinet",
+	"fireboat",
+	"fire engine, fire truck",
+	"fire screen, fireguard",
+	"flagpole, flagstaff",
+	"flute, transverse flute",
+	"folding chair",
+	"football helmet",
+	"forklift",
+	"fountain",
+	"fountain pen",
+	"four-poster",
+	"freight car",
+	"French horn, horn",
+	"frying pan, frypan, skillet",
+	"fur coat",
+	"garbage truck, dustcart",
+	"gasmask, respirator, gas helmet",
+	"gas pump, gasoline pump, petrol pump, island dispenser",
+	"goblet",
+	"go-kart",
+	"golf ball",
+	"golfcart, golf cart",
+	"gondola",
+	"gong, tam-tam",
+	"gown",
+	"grand piano, grand",
+	"greenhouse, nursery, glasshouse",
+	"grille, radiator grille",
+	"grocery store, grocery, food market, market",
+	"guillotine",
+	"hair slide",
+	"hair spray",
+	"half track",
+	"hammer",
+	"hamper",
+	"hand blower, blow dryer, blow drier, hair dryer, hair drier",
+	"hand-held computer, hand-held microcomputer",
+	"handkerchief, hankie, hanky, hankey",
+	"hard disc, hard disk, fixed disk",
+	"harmonica, mouth organ, harp, mouth harp",
+	"harp",
+	"harvester, reaper",
+	"hatchet",
+	"holster",
+	"home theater, home theatre",
+	"honeycomb",
+	"hook, claw",
+	"hoopskirt, crinoline",
+	"horizontal bar, high bar",
+	"horse cart, horse-cart",
+	"hourglass",
+	"iPod",
+	"iron, smoothing iron",
+	"jack-o'-lantern",
+	"jean, blue jean, denim",
+	"jeep, landrover",
+	"jersey, T-shirt, tee shirt",
+	"jigsaw puzzle",
+	"jinrikisha, ricksha, rickshaw",
+	"joystick",
+	"kimono",
+	"knee pad",
+	"knot",
+	"lab coat, laboratory coat",
+	"ladle",
+	"lampshade, lamp shade",
+	"laptop, laptop computer",
+	"lawn mower, mower",
+	"lens cap, lens cover",
+	"letter opener, paper knife, paperknife",
+	"library",
+	"lifeboat",
+	"lighter, light, igniter, ignitor",
+	"limousine, limo",
+	"liner, ocean liner",
+	"lipstick, lip rouge",
+	"Loafer",
+	"lotion",
+	"loudspeaker, speaker, speaker unit, loudspeaker system, speaker system",
+	"loupe, jeweler's loupe",
+	"lumbermill, sawmill",
+	"magnetic compass",
+	"mailbag, postbag",
+	"mailbox, letter box",
+	"maillot",
+	"maillot, tank suit",
+	"manhole cover",
+	"maraca",
+	"marimba, xylophone",
+	"mask",
+	"matchstick",
+	"maypole",
+	"maze, labyrinth",
+	"measuring cup",
+	"medicine chest, medicine cabinet",
+	"megalith, megalithic structure",
+	"microphone, mike",
+	"microwave, microwave oven",
+	"military uniform",
+	"milk can",
+	"minibus",
+	"miniskirt, mini",
+	"minivan",
+	"missile",
+	"mitten",
+	"mixing bowl",
+	"mobile home, manufactured home",
+	"Model T",
+	"modem",
+	"monastery",
+	"monitor",
+	"moped",
+	"mortar",
+	"mortarboard",
+	"mosque",
+	"mosquito net",
+	"motor scooter, scooter",
+	"mountain bike, all-terrain bike, off-roader",
+	"mountain tent",
+	"mouse, computer mouse",
+	"mousetrap",
+	"moving van",
+	"muzzle",
+	"nail",
+	"neck brace",
+	"necklace",
+	"nipple",
+	"notebook, notebook computer",
+	"obelisk",
+	"oboe, hautboy, hautbois",
+	"ocarina, sweet potato",
+	"odometer, hodometer, mileometer, milometer",
+	"oil filter",
+	"organ, pipe organ",
+	"oscilloscope, scope, cathode-ray oscilloscope, CRO",
+	"overskirt",
+	"oxcart",
+	"oxygen mask",
+	"packet",
+	"paddle, boat paddle",
+	"paddlewheel, paddle wheel",
+	"padlock",
+	"paintbrush",
+	"pajama, pyjama, pj's, jammies",
+	"palace",
+	"panpipe, pandean pipe, syrinx",
+	"paper towel",
+	"parachute, chute",
+	"parallel bars, bars",
+	"park bench",
+	"parking meter",
+	"passenger car, coach, carriage",
+	"patio, terrace",
+	"pay-phone, pay-station",
+	"pedestal, plinth, footstall",
+	"pencil box, pencil case",
+	"pencil sharpener",
+	"perfume, essence",
+	"Petri dish",
+	"photocopier",
+	"pick, plectrum, plectron",
+	"pickelhaube",
+	"picket fence, paling",
+	"pickup, pickup truck",
+	"pier",
+	"piggy bank, penny bank",
+	"pill bottle",
+	"pillow",
+	"ping-pong ball",
+	"pinwheel",
+	"pirate, pirate ship",
+	"pitcher, ewer",
+	"plane, carpenter's plane, woodworking plane",
+	"planetarium",
+	"plastic bag",
+	"plate rack",
+	"plow, plough",
+	"plunger, plumber's helper",
+	"Polaroid camera, Polaroid Land camera",
+	"pole",
+	"police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria",
+	"poncho",
+	"pool table, billiard table, snooker table",
+	"pop bottle, soda bottle",
+	"pot, flowerpot",
+	"potter's wheel",
+	"power drill",
+	"prayer rug, prayer mat",
+	"printer",
+	"prison, prison house",
+	"projectile, missile",
+	"projector",
+	"puck, hockey puck",
+	"punching bag, punch bag, punching ball, punchball",
+	"purse",
+	"quill, quill pen",
+	"quilt, comforter, comfort, puff",
+	"racer, race car, racing car",
+	"racket, racquet",
+	"radiator",
+	"radio, wireless",
+	"radio telescope, radio reflector",
+	"rain barrel",
+	"recreational vehicle, RV, R.V.",
+	"reel",
+	"reflex camera",
+	"refrigerator, icebox",
+	"remote control, remote",
+	"restaurant, eating house, eating place, eatery",
+	"revolver, six-gun, six-shooter",
+	"rifle",
+	"rocking chair, rocker",
+	"rotisserie",
+	"rubber eraser, rubber, pencil eraser",
+	"rugby ball",
+	"rule, ruler",
+	"running shoe",
+	"safe",
+	"safety pin",
+	"saltshaker, salt shaker",
+	"sandal",
+	"sarong",
+	"sax, saxophone",
+	"scabbard",
+	"scale, weighing machine",
+	"school bus",
+	"schooner",
+	"scoreboard",
+	"screen, CRT screen",
+	"screw",
+	"screwdriver",
+	"seat belt, seatbelt",
+	"sewing machine",
+	"shield, buckler",
+	"shoe shop, shoe-shop, shoe store",
+	"shoji",
+	"shopping basket",
+	"shopping cart",
+	"shovel",
+	"shower cap",
+	"shower curtain",
+	"ski",
+	"ski mask",
+	"sleeping bag",
+	"slide rule, slipstick",
+	"sliding door",
+	"slot, one-armed bandit",
+	"snorkel",
+	"snowmobile",
+	"snowplow, snowplough",
+	"soap dispenser",
+	"soccer ball",
+	"sock",
+	"solar dish, solar collector, solar furnace",
+	"sombrero",
+	"soup bowl",
+	"space bar",
+	"space heater",
+	"space shuttle",
+	"spatula",
+	"speedboat",
+	"spider web, spider's web",
+	"spindle",
+	"sports car, sport car",
+	"spotlight, spot",
+	"stage",
+	"steam locomotive",
+	"steel arch bridge",
+	"steel drum",
+	"stethoscope",
+	"stole",
+	"stone wall",
+	"stopwatch, stop watch",
+	"stove",
+	"strainer",
+	"streetcar, tram, tramcar, trolley, trolley car",
+	"stretcher",
+	"studio couch, day bed",
+	"stupa, tope",
+	"submarine, pigboat, sub, U-boat",
+	"suit, suit of clothes",
+	"sundial",
+	"sunglass",
+	"sunglasses, dark glasses, shades",
+	"sunscreen, sunblock, sun blocker",
+	"suspension bridge",
+	"swab, swob, mop",
+	"sweatshirt",
+	"swimming trunks, bathing trunks",
+	"swing",
+	"switch, electric switch, electrical switch",
+	"syringe",
+	"table lamp",
+	"tank, army tank, armored combat vehicle, armoured combat vehicle",
+	"tape player",
+	"teapot",
+	"teddy, teddy bear",
+	"television, television system",
+	"tennis ball",
+	"thatch, thatched roof",
+	"theater curtain, theatre curtain",
+	"thimble",
+	"thresher, thrasher, threshing machine",
+	"throne",
+	"tile roof",
+	"toaster",
+	"tobacco shop, tobacconist shop, tobacconist",
+	"toilet seat",
+	"torch",
+	"totem pole",
+	"tow truck, tow car, wrecker",
+	"toyshop",
+	"tractor",
+	"trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi",
+	"tray",
+	"trench coat",
+	"tricycle, trike, velocipede",
+	"trimaran",
+	"tripod",
+	"triumphal arch",
+	"trolleybus, trolley coach, trackless trolley",
+	"trombone",
+	"tub, vat",
+	"turnstile",
+	"typewriter keyboard",
+	"umbrella",
+	"unicycle, monocycle",
+	"upright, upright piano",
+	"vacuum, vacuum cleaner",
+	"vase",
+	"vault",
+	"velvet",
+	"vending machine",
+	"vestment",
+	"viaduct",
+	"violin, fiddle",
+	"volleyball",
+	"waffle iron",
+	"wall clock",
+	"wallet, billfold, notecase, pocketbook",
+	"wardrobe, closet, press",
+	"warplane, military plane",
+	"washbasin, handbasin, washbowl, lavabo, wash-hand basin",
+	"washer, automatic washer, washing machine",
+	"water bottle",
+	"water jug",
+	"water tower",
+	"whiskey jug",
+	"whistle",
+	"wig",
+	"window screen",
+	"window shade",
+	"Windsor tie",
+	"wine bottle",
+	"wing",
+	"wok",
+	"wooden spoon",
+	"wool, woolen, woollen",
+	"worm fence, snake fence, snake-rail fence, Virginia fence",
+	"wreck",
+	"yawl",
+	"yurt",
+	"web site, website, internet site, site",
+	"comic book",
+	"crossword puzzle, crossword",
+	"street sign",
+	"traffic light, traffic signal, stoplight",
+	"book jacket, dust cover, dust jacket, dust wrapper",
+	"menu",
+	"plate",
+	"guacamole",
+	"consomme",
+	"hot pot, hotpot",
+	"trifle",
+	"ice cream, icecream",
+	"ice lolly, lolly, lollipop, popsicle",
+	"French loaf",
+	"bagel, beigel",
+	"pretzel",
+	"cheeseburger",
+	"hotdog, hot dog, red hot",
+	"mashed potato",
+	"head cabbage",
+	"broccoli",
+	"cauliflower",
+	"zucchini, courgette",
+	"spaghetti squash",
+	"acorn squash",
+	"butternut squash",
+	"cucumber, cuke",
+	"artichoke, globe artichoke",
+	"bell pepper",
+	"cardoon",
+	"mushroom",
+	"Granny Smith",
+	"strawberry",
+	"orange",
+	"lemon",
+	"fig",
+	"pineapple, ananas",
+	"banana",
+	"jackfruit, jak, jack",
+	"custard apple",
+	"pomegranate",
+	"hay",
+	"carbonara",
+	"chocolate sauce, chocolate syrup",
+	"dough",
+	"meat loaf, meatloaf",
+	"pizza, pizza pie",
+	"potpie",
+	"burrito",
+	"red wine",
+	"espresso",
+	"cup",
+	"eggnog",
+	"alp",
+	"bubble",
+	"cliff, drop, drop-off",
+	"coral reef",
+	"geyser",
+	"lakeside, lakeshore",
+	"promontory, headland, head, foreland",
+	"sandbar, sand bar",
+	"seashore, coast, seacoast, sea-coast",
+	"valley, vale",
+	"volcano",
+	"ballplayer, baseball player",
+	"groom, bridegroom",
+	"scuba diver",
+	"rapeseed",
+	"daisy",
+	"yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum",
+	"corn",
+	"acorn",
+	"hip, rose hip, rosehip",
+	"buckeye, horse chestnut, conker",
+	"coral fungus",
+	"agaric",
+	"gyromitra",
+	"stinkhorn, carrion fungus",
+	"earthstar",
+	"hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa",
+	"bolete",
+	"ear, spike, capitulum",
+	"toilet tissue, toilet paper, bathroom tissue"
+];
+//#endregion
+//#region src/zoo/mobilenetv4/pipeline.ts
+/** Logits [numClasses] → top-k class probabilities (softmax over ALL classes). */
+function decodeTopK(logits, k = 5) {
+	let max = -Infinity;
+	for (const v of logits) max = Math.max(max, v);
+	let sum = 0;
+	const exps = new Float64Array(logits.length);
+	for (let i = 0; i < logits.length; i++) {
+		exps[i] = Math.exp(logits[i] - max);
+		sum += exps[i];
+	}
+	return Array.from(exps.keys()).sort((a, b) => exps[b] - exps[a]).slice(0, k).map((classId) => ({
+		classId,
+		confidence: exps[classId] / sum
+	}));
+}
+//#endregion
+//#region src/zoo/tasks/cv/imageClassification.ts
+/** Image classification task: an image in, the classes it shows out, best
+*  first. Runs MobileNetV4 on the initRunntime() device. */
+/** 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'] } })");
+	const scope = createResourceScope();
+	try {
+		const { modelPath = models.imageClassification.MOBILENETV4.DEFAULT.modelPath, labels = IMAGENET1K_LABELS, resizeMode = "crop" } = config;
+		const path = typeof modelPath === "string" ? modelPath.replace(/^https?:\/\//, "") : void 0;
+		const sd = await openWeights(modelPath, {
+			...opts,
+			cacheId: opts.cacheId ?? (path && `mobilenetv4-v1/${path}`)
+		});
+		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`);
+		const preprocessor = createImagePreprocessor({
+			resizeMode,
+			cropFraction: MOBILENETV4_CROP_FRACTION,
+			normalizeOpts: {
+				alpha: IMAGENET_STD.map((s) => 1 / (255 * s)),
+				beta: IMAGENET_MEAN.map((m, c) => -m / IMAGENET_STD[c])
+			}
+		}, {
+			width: inputSize,
+			height: inputSize
+		});
+		const pixels = new Float32Array(3 * inputSize * inputSize);
+		let disposed = false;
+		let queue = Promise.resolve();
+		return {
+			labels,
+			inputSize,
+			async classify(image, options = {}) {
+				if (disposed) throw new Error("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}`);
+				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 }) => ({
+					label: labels[classId],
+					classId,
+					confidence
+				}));
+			},
+			dispose() {
+				disposed = true;
+				scope.dispose();
+			}
+		};
+	} catch (err) {
+		scope.dispose();
+		throw err;
+	}
+}
+//#endregion
+export { COCO_LANDMARKS, SPEECH_SAMPLE_RATE, bufferSource, createDepthEstimator, createImageClassifier, createInstanceSegmenter, createKeypointDetector, createObjectDetector, createOpfsCache, createPrivacyFilter, createSpeechToText, createTextEmbedder, decodeAudio, imageBuffer, imageBufferFromImageData, initRunntime, models, resampleAudio, similarity };