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

package/dist/zoo/transformers/index.mjs

@@ -0,0 +1,674 @@
+import { $ as initRunntime, D as V2_NER_CLASS_NAMES, E as loadPrivacyFilterModel, F as createOpfsCache, G as inGpuErrorScopes, I as createReplayCache, N as MINILM_L6, O as MinilmModel, P as models, S as configFromCheckpoint, X as httpRangeSource, Y as fromSafetensors, b as MOONSHINE_TINY, c as createDetector, et as toArray, ht as supportsF16, i as MOBILENETV4_CONV_S, j as fillBucketInputs, k as MINILM_BUCKETS, l as createTranscriber, mt as defaultRoot, q as bufferSource, s as createEstimator, t as createClassifier, x as assertConfigMatches, y as MOONSHINE_BASE } from "../../classifier-ByH6OI6h.mjs";
+import tgpu from "typegpu";
+import { AutoConfig, PreTrainedModel, Tensor } from "@huggingface/transformers";
+//#region src/zoo/transformers/minilm/model.ts
+function fillReplayInputs(T, ids, out) {
+	fillBucketInputs(T, ids, {
+		...out,
+		selector: new Float32Array(T)
+	});
+}
+var RunntimeBertModel = class extends PreTrainedModel {
+	runntime;
+	replays;
+	constructor(config, runntime) {
+		super(config, {}, {});
+		this.runntime = runntime;
+		this.replays = createReplayCache({
+			buckets: MINILM_BUCKETS,
+			inputs: (T) => ({
+				ids: [T, 1],
+				positions: [T, 1],
+				segments: [T, 2]
+			}),
+			captureFill: (T, scratch) => fillReplayInputs(T, new Array(T).fill(0), scratch),
+			build: (T, inp) => this.runntime.forward(inp.ids, {
+				positions: inp.positions,
+				segments: inp.segments,
+				maxSegment: T
+			})
+		});
+	}
+	/** transformers.js's release hook: frees the recorded replays and the
+	*  GPU weights. Returns the (empty) ONNX-session list callers may await. */
+	async dispose() {
+		this.replays.dispose();
+		this.runntime.dispose();
+		return [];
+	}
+	warm() {
+		return this.replays.warmAll();
+	}
+	async forward(modelInputs) {
+		const inputIds = modelInputs["input_ids"];
+		if (!inputIds) throw new Error("runntime backend: model inputs are missing input_ids");
+		const mask = modelInputs["attention_mask"];
+		const [batch, seqLen] = inputIds.dims;
+		const idsData = inputIds.data;
+		const maskData = mask?.data;
+		const rows = [];
+		const slots = [];
+		for (let b = 0; b < batch; b++) {
+			const row = [];
+			const slot = [];
+			for (let t = 0; t < seqLen; t++) {
+				const i = b * seqLen + t;
+				if (maskData === void 0 || Number(maskData[i]) !== 0) {
+					row.push(Number(idsData[i]));
+					slot.push(t);
+				}
+			}
+			rows.push(row);
+			slots.push(slot);
+		}
+		const hidden = MINILM_L6.hidden;
+		const out = new Float32Array(batch * seqLen * hidden);
+		const writeRow = (flat, srcRow, b) => {
+			for (const [k, t] of slots[b].entries()) out.set(flat.subarray((srcRow + k) * hidden, (srcRow + k + 1) * hidden), (b * seqLen + t) * hidden);
+		};
+		const bucket = batch === 1 ? this.replays.pick(rows[0].length) : void 0;
+		if (bucket !== void 0) {
+			const row = rows[0];
+			writeRow(await this.replays.run(bucket, (T, scratch) => fillReplayInputs(T, row, scratch)), 0, 0);
+			return { last_hidden_state: new Tensor("float32", out, [
+				batch,
+				seqLen,
+				hidden
+			]) };
+		}
+		const packed = rows.flat();
+		const lengths = rows.map((r) => r.length);
+		const device = defaultRoot().device;
+		const flat = await inGpuErrorScopes(device, "inference", () => toArray(this.runntime.forward(packed, batch > 1 ? lengths : void 0)));
+		let srcRow = 0;
+		rows.forEach((row, b) => {
+			writeRow(flat, srcRow, b);
+			srcRow += row.length;
+		});
+		return { last_hidden_state: new Tensor("float32", out, [
+			batch,
+			seqLen,
+			hidden
+		]) };
+	}
+};
+//#endregion
+//#region src/zoo/transformers/weights.ts
+/** The cache key of a weights URL: the whole path without the scheme, so
+*  same-named files of two sizes or precisions stay apart. */
+function cacheKey(url) {
+	return url.replace(/^https?:\/\//, "");
+}
+/** Loads a safetensors file too big to hold in memory: byte ranges are
+*  fetched per tensor and saved in OPFS under `cacheId`. */
+async function loadStreamedWeights(url, cacheId) {
+	const cache = await createOpfsCache("runntime-weights");
+	return fromSafetensors(url, {
+		cache,
+		cacheId
+	});
+}
+async function cachedWeightsSource(url, key) {
+	const cache = await createOpfsCache("runntime-weights");
+	if (!cache) return httpRangeSource(url);
+	const fetchAll = async () => {
+		const res = await fetch(url);
+		if (!res.ok) throw new Error(`runntime backend: fetching weights failed (${res.status})`);
+		return new Uint8Array(await res.arrayBuffer());
+	};
+	const fromCache = async () => bufferSource(await cache.getOrCompute(key, fetchAll));
+	let source = await fromCache();
+	try {
+		await fromSafetensors(source);
+	} catch {
+		await cache.deletePrefix(key);
+		source = await fromCache();
+		try {
+			await fromSafetensors(source);
+		} catch (err) {
+			throw new Error(`runntime backend: ${url} is not a safetensors file`, { cause: err });
+		}
+	}
+	return source;
+}
+async function loadCachedWeights(url, key) {
+	return fromSafetensors(await cachedWeightsSource(url, key));
+}
+//#endregion
+//#region src/zoo/transformers/minilm/loader.ts
+/** The hosted f16 export; loadStateDict fuses qkv and folds the token-type
+*  embedding while loading it. */
+const MINILM_WEIGHTS_URL = models.textEmbedding.ALL_MINILM_L6_V2.DEFAULT.modelPath;
+const MINILM_MODEL_IDS = ["Xenova/all-MiniLM-L6-v2", "sentence-transformers/all-MiniLM-L6-v2"];
+function minilmLoader(weightsUrl = MINILM_WEIGHTS_URL) {
+	return { async load(_modelId, config) {
+		defaultRoot();
+		const sd = await loadCachedWeights(weightsUrl, `whole/minilm-v1/${cacheKey(weightsUrl)}`);
+		const model = new MinilmModel(MINILM_L6);
+		if (supportsF16()) model.half();
+		await model.loadStateDict(sd);
+		const wrapped = new RunntimeBertModel(config, model);
+		await inGpuErrorScopes(defaultRoot().device, "plugin warm-up", () => wrapped.warm());
+		return wrapped;
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/privacy-filter/model.ts
+/** Labels per token: 'O' plus 8 span types × 4 boundary tags. */
+const PRIVACY_FILTER_LABELS = V2_NER_CLASS_NAMES.length;
+var RunntimePrivacyFilterForTokenClassification = class extends PreTrainedModel {
+	runntime;
+	constructor(config, runntime) {
+		super(config, {}, {});
+		this.runntime = runntime;
+	}
+	/** transformers.js's release hook (`await model.dispose()`): frees the
+	*  GPU weights. The ONNX-session array it normally returns is empty here. */
+	async dispose() {
+		this.runntime.dispose();
+		return [];
+	}
+	async forward(modelInputs) {
+		const inputIds = modelInputs["input_ids"];
+		if (!inputIds) throw new Error("runntime backend: model inputs are missing input_ids");
+		const mask = modelInputs["attention_mask"];
+		const [batch, seqLen] = inputIds.dims;
+		const idsData = inputIds.data;
+		const maskData = mask?.data;
+		const L = PRIVACY_FILTER_LABELS;
+		const out = new Float32Array(batch * seqLen * L);
+		const device = defaultRoot().device;
+		await inGpuErrorScopes(device, "inference", async () => {
+			for (let b = 0; b < batch; b++) {
+				const row = [];
+				const slots = [];
+				for (let t = 0; t < seqLen; t++) {
+					const i = b * seqLen + t;
+					if (maskData === void 0 || Number(maskData[i]) !== 0) {
+						row.push(Number(idsData[i]));
+						slots.push(t);
+					}
+				}
+				if (row.length === 0) continue;
+				const logits = await toArray(this.runntime.forward(row));
+				checkLogits(logits);
+				for (const [k, t] of slots.entries()) out.set(logits.subarray(k * L, (k + 1) * L), (b * seqLen + t) * L);
+			}
+		});
+		return { logits: new Tensor("float32", out, [
+			batch,
+			seqLen,
+			L
+		]) };
+	}
+};
+function checkLogits(logits) {
+	if (!logits.every(Number.isFinite)) throw new Error("runntime backend: GPU returned non-finite logits — inference failed on this device");
+	if (logits.every((v) => v === 0)) throw new Error("runntime backend: GPU returned all-zero logits — inference failed on this device");
+}
+//#endregion
+//#region src/zoo/transformers/privacy-filter/loader.ts
+/** The hosted int8 export, 1.55 GB. */
+const PRIVACY_FILTER_WEIGHTS_URL = models.privacyFilter.PRIVACY_FILTER.DEFAULT.modelPath;
+const PRIVACY_FILTER_MODEL_IDS = ["openai/privacy-filter"];
+const EXPECTED_CONFIG = {
+	hidden_size: 640,
+	num_hidden_layers: 8,
+	num_local_experts: 128,
+	num_experts_per_tok: 4
+};
+function assertPrivacyFilterConfig(config) {
+	const cfg = config;
+	for (const [key, expected] of Object.entries(EXPECTED_CONFIG)) if (cfg[key] !== expected) throw new Error(`runntime backend: privacy-filter config ${key} is ${String(cfg[key])}, expected ${expected}`);
+	const id2label = cfg["id2label"];
+	if (!id2label) throw new Error("runntime backend: privacy-filter config is missing id2label");
+	V2_NER_CLASS_NAMES.forEach((name, i) => {
+		if (id2label[String(i)] !== name) throw new Error(`runntime backend: privacy-filter label ${i} is '${id2label[String(i)]}', expected '${name}'`);
+	});
+}
+function privacyFilterLoader(weightsUrl = PRIVACY_FILTER_WEIGHTS_URL, opts = {}) {
+	return { async load(_modelId, config) {
+		defaultRoot();
+		assertPrivacyFilterConfig(config);
+		const sd = await loadStreamedWeights(weightsUrl, `range/privacy-filter-v1/${cacheKey(weightsUrl)}`);
+		const { model } = await loadPrivacyFilterModel(sd, { onProgress: opts.onProgress });
+		return new RunntimePrivacyFilterForTokenClassification(config, model);
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/moonshine/model.ts
+/** Speech-to-text stand-in running the zoo moonshine transcriber. The
+*  pipeline hands over 16 kHz audio as `input_values` [1, samples] and
+*  gets back the generated ids as int64 [1, L], BOS first, EOS last when
+*  reached; it decodes the text with the hub tokenizer. The transcriber
+*  does everything from audio to ids: encoder, greedy burst decode, and
+*  splitting clips longer than its chunk limit. */
+var RunntimeMoonshineForConditionalGeneration = class extends PreTrainedModel {
+	runntime;
+	tokens;
+	/** Encode and decode wall time of the last generate() call, for
+	*  benchmarks; the pipeline itself never reads it. */
+	lastTimings;
+	constructor(config, runntime, tokens) {
+		super(config, {}, {});
+		this.runntime = runntime;
+		this.tokens = tokens;
+	}
+	/** transformers.js's release hook: frees the weights, KV caches and rope
+	*  tables. Returns the (empty) ONNX-session list callers may await. */
+	async dispose() {
+		this.runntime.dispose();
+		return [];
+	}
+	async generate(options) {
+		const audio = options["input_values"] ?? options.inputs;
+		if (!audio) throw new Error("runntime backend: moonshine generate() needs input_values");
+		if (audio.dims.length !== 2 || audio.dims[0] !== 1) throw new Error(`runntime backend: moonshine takes one clip per call, got input_values [${audio.dims}]`);
+		const samples = audio.data;
+		let ids = [this.tokens.bos, this.tokens.eos];
+		if (samples.length >= 895) {
+			const result = await inGpuErrorScopes(defaultRoot().device, "inference", () => this.runntime.transcribe(samples));
+			ids = result.ids;
+			this.lastTimings = result.timings;
+		}
+		return new Tensor("int64", BigInt64Array.from(ids.map(BigInt)), [1, ids.length]);
+	}
+};
+//#endregion
+//#region src/zoo/transformers/moonshine/loader.ts
+/** The hosted f16 exports, picked by the hub config's size. */
+const MOONSHINE_WEIGHTS_URLS = {
+	tiny: models.speechToText.MOONSHINE.TINY.DEFAULT.modelPath,
+	base: models.speechToText.MOONSHINE.BASE.DEFAULT.modelPath
+};
+const MOONSHINE_MODEL_IDS = ["onnx-community/moonshine-tiny-ONNX", "onnx-community/moonshine-base-ONNX"];
+function moonshinePreset(config) {
+	const parsed = configFromCheckpoint(config);
+	const size = parsed.dModel === MOONSHINE_TINY.dModel ? "tiny" : parsed.dModel === MOONSHINE_BASE.dModel ? "base" : void 0;
+	if (!size) throw new Error(`runntime backend: moonshine hidden_size ${parsed.dModel} is neither tiny nor base`);
+	const cfg = size === "tiny" ? MOONSHINE_TINY : MOONSHINE_BASE;
+	assertConfigMatches({
+		...parsed,
+		maxPositions: cfg.maxPositions
+	}, cfg);
+	return {
+		size,
+		cfg
+	};
+}
+function idsOnlyTokenizer(cfg) {
+	return {
+		version: 0,
+		bosId: cfg.bos,
+		eosId: cfg.eos,
+		specialIds: [cfg.bos, cfg.eos],
+		vocab: new Array(cfg.vocab).fill("")
+	};
+}
+function moonshineLoader(weightsUrl, opts = {}) {
+	return { async load(_modelId, config) {
+		defaultRoot();
+		const { size, cfg } = moonshinePreset(config);
+		const url = weightsUrl ?? MOONSHINE_WEIGHTS_URLS[size];
+		const source = await cachedWeightsSource(url, `whole/moonshine-v1/${cacheKey(url)}`);
+		const sd = await fromSafetensors(source);
+		const transcriber = await createTranscriber(sd, idsOnlyTokenizer(cfg), {
+			cfg,
+			weightDtype: opts.weightDtype ?? (supportsF16() ? "f16" : "f32"),
+			onProgress: opts.onProgress
+		});
+		await inGpuErrorScopes(defaultRoot().device, "plugin warm-up", () => transcriber.transcribe(/* @__PURE__ */ new Float32Array(16e3)));
+		return new RunntimeMoonshineForConditionalGeneration(config, transcriber, cfg);
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/mobilenetv4/model.ts
+var RunntimeMobileNetV4ForImageClassification = class extends PreTrainedModel {
+	runntime;
+	constructor(config, runntime) {
+		super(config, {}, {});
+		this.runntime = runntime;
+	}
+	/** transformers.js's release hook; the ONNX-session array it normally
+	*  returns is empty here. */
+	async dispose() {
+		this.runntime.dispose();
+		return [];
+	}
+	async forward(inputs) {
+		const pixels = inputs["pixel_values"];
+		if (!pixels) throw new Error("runntime backend: mobilenetv4 forward() needs pixel_values");
+		const { inputSize: size, numClasses } = this.runntime;
+		if (pixels.dims.length !== 4 || pixels.dims[1] !== 3) throw new Error(`runntime backend: mobilenetv4 takes pixel_values [N, 3, ${size}, ${size}], got [${pixels.dims}]`);
+		const [n, , h, w] = pixels.dims;
+		if (h !== size || w !== size) throw new Error(`runntime backend: mobilenetv4 takes ${size}×${size} images, got pixel_values [${pixels.dims}]`);
+		const out = new Float32Array(n * numClasses);
+		const data = pixels.data;
+		const stride = 3 * size * size;
+		for (let i = 0; i < n; i++) {
+			const logits = await inGpuErrorScopes(defaultRoot().device, "inference", () => this.runntime.run(data.subarray(i * stride, (i + 1) * stride)));
+			out.set(logits, i * numClasses);
+		}
+		return { logits: new Tensor("float32", out, [n, numClasses]) };
+	}
+};
+//#endregion
+//#region src/zoo/transformers/mobilenetv4/loader.ts
+/** The timm checkpoint (f32, 15 MB), loaded as f16 with the batch norms
+*  folded into their convs. */
+const MOBILENETV4_WEIGHTS_URL = models.imageClassification.MOBILENETV4.DEFAULT.modelPath;
+const MOBILENETV4_MODEL_IDS = ["onnx-community/mobilenetv4_conv_small.e2400_r224_in1k"];
+function assertMobilenetv4Config(config) {
+	const cfg = config;
+	const id2label = cfg["id2label"];
+	const numClasses = id2label ? Object.keys(id2label).length : cfg["num_classes"];
+	if (numClasses !== void 0 && numClasses !== MOBILENETV4_CONV_S.numClasses) throw new Error(`runntime backend: mobilenetv4 config has ${String(numClasses)} classes, expected ${MOBILENETV4_CONV_S.numClasses}`);
+	const inputSize = cfg["input_size"];
+	const side = MOBILENETV4_CONV_S.inputSize;
+	if (inputSize && (inputSize[1] !== side || inputSize[2] !== side)) throw new Error(`runntime backend: mobilenetv4 config input_size is [${inputSize}], expected [3, ${side}, ${side}]`);
+}
+function mobilenetv4Loader(weightsUrl = MOBILENETV4_WEIGHTS_URL, opts = {}) {
+	return { async load(_modelId, config) {
+		defaultRoot();
+		assertMobilenetv4Config(config);
+		const source = await cachedWeightsSource(weightsUrl, `whole/mobilenetv4-v1/${cacheKey(weightsUrl)}`);
+		return new RunntimeMobileNetV4ForImageClassification(config, await createClassifier(await fromSafetensors(source), { onProgress: opts.onProgress }));
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/yolo26/output.ts
+/** `a` ranks above `b`: higher score, index breaks ties. */
+const beats = (score, a, b) => score[a] > score[b] || score[a] === score[b] && a < b;
+function topIndices(score, k) {
+	const n = score.length;
+	const size = Math.min(k, n);
+	const heap = new Int32Array(size);
+	let len = 0;
+	const siftDown = (start) => {
+		let i = start;
+		for (;;) {
+			const l = 2 * i + 1;
+			const r = l + 1;
+			let worst = i;
+			if (l < len && beats(score, heap[worst], heap[l])) worst = l;
+			if (r < len && beats(score, heap[worst], heap[r])) worst = r;
+			if (worst === i) return;
+			const t = heap[i];
+			heap[i] = heap[worst];
+			heap[worst] = t;
+			i = worst;
+		}
+	};
+	for (let i = 0; i < n; i++) if (len < size) {
+		heap[len] = i;
+		let j = len++;
+		while (j > 0) {
+			const parent = j - 1 >> 1;
+			if (!beats(score, heap[parent], heap[j])) break;
+			const t = heap[j];
+			heap[j] = heap[parent];
+			heap[parent] = t;
+			j = parent;
+		}
+	} else if (beats(score, i, heap[0])) {
+		heap[0] = i;
+		siftDown(0);
+	}
+	return Array.from(heap.subarray(0, len)).sort((a, b) => beats(score, a, b) ? -1 : 1);
+}
+function selectTopAnchors(levels, opts) {
+	const { numClasses, maxDet, inputSize } = opts;
+	const total = levels.reduce((n, l) => n + l.h * l.w, 0);
+	const best = new Float32Array(total).fill(-Infinity);
+	let base = 0;
+	for (const { data, h, w } of levels) {
+		const hw = h * w;
+		for (let c = 0; c < numClasses; c++) {
+			const plane = (4 + c) * hw;
+			for (let i = 0; i < hw; i++) {
+				const v = data[plane + i];
+				if (v > best[base + i]) best[base + i] = v;
+			}
+		}
+		base += hw;
+	}
+	const order = topIndices(best, maxDet);
+	const count = Math.min(maxDet, total);
+	const outClasses = numClasses + 1;
+	const logits = new Float32Array(count * outClasses);
+	const boxes = new Float32Array(count * 4);
+	for (let k = 0; k < count; k++) {
+		let idx = order[k];
+		let level = 0;
+		while (idx >= levels[level].h * levels[level].w) {
+			idx -= levels[level].h * levels[level].w;
+			level++;
+		}
+		const { data, h, w, stride } = levels[level];
+		const hw = h * w;
+		for (let c = 0; c < numClasses; c++) logits[k * outClasses + c] = data[(4 + c) * hw + idx];
+		const ax = idx % w + .5;
+		const ay = Math.floor(idx / w) + .5;
+		const l = data[idx];
+		const t = data[hw + idx];
+		const r = data[2 * hw + idx];
+		const b = data[3 * hw + idx];
+		const scale = stride / inputSize;
+		boxes[k * 4] = (ax + (r - l) / 2) * scale;
+		boxes[k * 4 + 1] = (ay + (b - t) / 2) * scale;
+		boxes[k * 4 + 2] = (l + r) * scale;
+		boxes[k * 4 + 3] = (t + b) * scale;
+	}
+	return {
+		logits,
+		boxes,
+		count,
+		outClasses
+	};
+}
+//#endregion
+//#region src/zoo/transformers/yolo26/model.ts
+var RunntimeYolosForObjectDetection = class extends PreTrainedModel {
+	runntime;
+	constructor(config, runntime) {
+		super(config, {}, {});
+		this.runntime = runntime;
+	}
+	/** transformers.js's release hook (`await model.dispose()`): frees the
+	*  GPU weights. The ONNX-session array it normally returns is empty here. */
+	async dispose() {
+		this.runntime.dispose();
+		return [];
+	}
+	async forward(inputs) {
+		const pixels = inputs["pixel_values"];
+		if (!pixels) throw new Error("runntime backend: yolo26 forward() needs pixel_values");
+		const { inputSize: size, numClasses } = this.runntime;
+		const [n, c, h, w] = pixels.dims;
+		if (n !== 1 || c !== 3 || h !== size || w !== size) throw new Error(`runntime backend: yolo26 takes one ${size}×${size} RGB image per call, got pixel_values [${pixels.dims}]`);
+		const { levels } = await inGpuErrorScopes(defaultRoot().device, "inference", () => this.runntime.run(pixels.data));
+		const top = selectTopAnchors(levels, {
+			numClasses,
+			maxDet: this.runntime.maxDet,
+			inputSize: size
+		});
+		return {
+			logits: new Tensor("float32", top.logits, [
+				1,
+				top.count,
+				top.outClasses
+			]),
+			pred_boxes: new Tensor("float32", top.boxes, [
+				1,
+				top.count,
+				4
+			])
+		};
+	}
+};
+//#endregion
+//#region src/zoo/transformers/yolo26/loader.ts
+/** The variant letter in a hub id such as `onnx-community/yolo26s-ONNX`. */
+function yolo26Variant(modelId) {
+	const m = /yolo26([nsmlx])(?![a-z])/i.exec(modelId);
+	if (!m) throw new Error(`runntime backend: cannot tell the yolo26 variant from '${modelId}'`);
+	return m[1].toLowerCase();
+}
+/** The hosted f16 exports, by variant. */
+const YOLO26_WEIGHTS_URLS = {
+	n: models.objectDetection.YOLO26.N.modelPath,
+	s: models.objectDetection.YOLO26.S.modelPath,
+	m: models.objectDetection.YOLO26.M.modelPath
+};
+/** Every hub id with a hosted export. */
+const YOLO26_MODEL_IDS = [
+	"onnx-community/yolo26n-ONNX",
+	"onnx-community/yolo26s-ONNX",
+	"onnx-community/yolo26m-ONNX"
+];
+/** `weightsUrl` defaults to the hosted export of the variant in the hub
+*  id; other variants need one. */
+function yolo26Loader(weightsUrl, opts = {}) {
+	return { async load(modelId, config) {
+		defaultRoot();
+		const variant = opts.variant ?? yolo26Variant(modelId);
+		const url = weightsUrl ?? YOLO26_WEIGHTS_URLS[variant];
+		if (!url) throw new Error(`runntime backend: no hosted yolo26${variant} weights, pass a weightsUrl`);
+		const source = await cachedWeightsSource(url, `whole/yolo26-v1/${cacheKey(url)}`);
+		return new RunntimeYolosForObjectDetection(config, {
+			...await createDetector(await fromSafetensors(source), {
+				task: "detect",
+				variant,
+				onProgress: opts.onProgress
+			}),
+			maxDet: 300
+		});
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/depthart/model.ts
+/** Depth-estimation stand-in running the zoo DepthART model. Takes the
+*  processor's normalized `pixel_values` [N, 3, H, W] and returns
+*  `predicted_depth` [N, S, S] at the model's own size; the stock
+*  post-processing resizes it to the image. Images run one at a time. */
+var RunntimeDepthartForDepthEstimation = class extends PreTrainedModel {
+	runntime;
+	constructor(config, runntime) {
+		super(config, {}, {});
+		this.runntime = runntime;
+	}
+	async forward(inputs) {
+		const pixels = inputs["pixel_values"];
+		if (!pixels) throw new Error("runntime backend: depthart forward() needs pixel_values");
+		if (pixels.dims.length !== 4 || pixels.dims[1] !== 3) throw new Error(`runntime backend: depthart takes pixel_values [N, 3, H, W], got [${pixels.dims}]`);
+		const [n, , h, w] = pixels.dims;
+		const size = this.runntime.inputSize;
+		const plane = size * size;
+		const out = new Float32Array(n * plane);
+		const data = pixels.data;
+		const stride = 3 * h * w;
+		for (let i = 0; i < n; i++) {
+			const depth = await inGpuErrorScopes(defaultRoot().device, "inference", () => this.runntime.run(data.subarray(i * stride, (i + 1) * stride), h, w));
+			out.set(depth, i * plane);
+		}
+		return { predicted_depth: new Tensor("float32", out, [
+			n,
+			size,
+			size
+		]) };
+	}
+};
+//#endregion
+//#region src/zoo/transformers/depthart/loader.ts
+/** The hosted f16 exports, keyed by the depth-estimation hub id they stand
+*  in for: one whose image processor normalizes with ImageNet statistics,
+*  since the pipeline keeps using that id's config and processor. */
+const DEPTHART_WEIGHTS_URLS = {
+	"onnx-community/depth-anything-v2-small": models.depthEstimation.DEPTHART.S.modelPath,
+	"onnx-community/depth-anything-v2-base": models.depthEstimation.DEPTHART.B.modelPath
+};
+const DEPTHART_MODEL_IDS = Object.keys(DEPTHART_WEIGHTS_URLS);
+/** `weightsUrl`: a safetensors export of a Fengxue93/DepthART relative
+*  checkpoint (tools/export_weights_depthart.py); defaults to the hosted
+*  export for the hub id. The variant is read from the file. */
+function depthartLoader(weightsUrl, opts = {}) {
+	return { async load(modelId, config) {
+		const root = defaultRoot();
+		const url = weightsUrl ?? DEPTHART_WEIGHTS_URLS[modelId];
+		if (!url) throw new Error(`runntime backend: no hosted DepthART weights for '${modelId}'`);
+		const source = await cachedWeightsSource(url, `whole/depthart-v1/${cacheKey(url)}`);
+		const sd = await fromSafetensors(source);
+		return new RunntimeDepthartForDepthEstimation(config, await inGpuErrorScopes(root.device, "plugin warm-up", () => createEstimator(sd, { onProgress: opts.onProgress })));
+	} };
+}
+//#endregion
+//#region src/zoo/transformers/registry.ts
+/** registerRunntimeBackend() patches PreTrainedModel.from_pretrained, the one
+*  loader that pipeline() and the AutoModel classes call, so registered hub
+*  ids load as TypeGPU zoo models. Tokenizers, processors and pipeline
+*  pre/post-processing stay stock transformers.js. Unregistered ids and
+*  loader failures throw; fallbackToOnnx warns and uses ONNX instead. */
+const registry = /* @__PURE__ */ new Map();
+let fallbackToOnnx = false;
+let original;
+function registerRunntimeBackend(opts = {}) {
+	registry.clear();
+	for (const id of MINILM_MODEL_IDS) registry.set(id, minilmLoader());
+	for (const id of PRIVACY_FILTER_MODEL_IDS) registry.set(id, privacyFilterLoader());
+	for (const id of MOONSHINE_MODEL_IDS) registry.set(id, moonshineLoader());
+	for (const id of MOBILENETV4_MODEL_IDS) registry.set(id, mobilenetv4Loader());
+	for (const id of YOLO26_MODEL_IDS) registry.set(id, yolo26Loader());
+	for (const id of DEPTHART_MODEL_IDS) registry.set(id, depthartLoader());
+	if (opts.models) for (const [id, loader] of Object.entries(opts.models)) registry.set(id, loader);
+	fallbackToOnnx = opts.fallbackToOnnx ?? false;
+	if (original) return;
+	original = PreTrainedModel.from_pretrained;
+	PreTrainedModel.from_pretrained = async function(...args) {
+		const [modelId, options = {}] = args;
+		const loader = typeof modelId === "string" ? registry.get(modelId) : void 0;
+		if (loader) try {
+			const config = await AutoConfig.from_pretrained(modelId, options);
+			return await loader.load(modelId, config);
+		} catch (e) {
+			if (!fallbackToOnnx) throw new Error(`runntime backend: loading '${modelId}' failed. Pass fallbackToOnnx: true to load it on ONNX instead.`, { cause: e });
+			console.warn(`runntime backend: loading '${modelId}' failed, falling back to ONNX`, e);
+		}
+		else if (!fallbackToOnnx) {
+			const ids = [...registry.keys()].join(", ");
+			throw new Error(`runntime backend: '${String(modelId)}' is not supported (registered ids: ${ids}). Pass fallbackToOnnx: true to load unsupported models on ONNX.`);
+		}
+		return original.call(this, ...args);
+	};
+}
+function unregisterRunntimeBackend() {
+	if (original) {
+		PreTrainedModel.from_pretrained = original;
+		original = void 0;
+	}
+	registry.clear();
+	fallbackToOnnx = false;
+}
+//#endregion
+//#region src/zoo/transformers/init.ts
+/** One-call plugin setup: creates the WebGPU device, points runntime/core at it
+*  and patches transformers.js. Requests subgroups, which the fast matmul
+*  and attention kernels need, and shader-f16, which yolo26 and depthart
+*  require and the other models use when present. Both are optional: a
+*  device lacking either still loads the f32-capable models. Options go
+*  straight to registerRunntimeBackend(), so `models` and `fallbackToOnnx` work
+*  here too. Returns the root for apps that also use TypeGPU directly. */
+async function initRunntimeBackend(opts = {}) {
+	const root = await tgpu.init({ device: { optionalFeatures: ["subgroups", "shader-f16"] } });
+	initRunntime(root);
+	registerRunntimeBackend(opts);
+	return root;
+}
+//#endregion
+//#region src/zoo/transformers/runntimeModel.ts
+/** True when a model is one of the plugin's TypeGPU ones, not the ONNX
+*  fallback. */
+function isRunntimeModel(model) {
+	return model instanceof RunntimeBertModel || model instanceof RunntimePrivacyFilterForTokenClassification || model instanceof RunntimeMoonshineForConditionalGeneration || model instanceof RunntimeYolosForObjectDetection || model instanceof RunntimeDepthartForDepthEstimation || model instanceof RunntimeMobileNetV4ForImageClassification;
+}
+//#endregion
+export { depthartLoader, initRunntimeBackend, isRunntimeModel, minilmLoader, mobilenetv4Loader, moonshineLoader, privacyFilterLoader, registerRunntimeBackend, unregisterRunntimeBackend, yolo26Loader };