@tryhamster/gerbil 1.11.4 → 1.12.0

package/dist/{gpu-CrzjQHv2.mjs → gpu-DRFhiv4R.mjs}

@@ -1,6 +1,6 @@
 import { a as resolveDefaultRepo, i as isTTSRepo, n as OUTETTS_ASSETS, r as OUTETTS_PRESET_VOICES, t as DEFAULT_MODELS } from "./defaults-DfGx4d1m.mjs";
-import { A as kaniSinTensor, C as computeKaniPositions, D as kaniAttentionLayerIndices, E as generateNanoCodecDecoderGraph, F as CANONICAL_KEYS, I as DTYPE_BYTES, L as GEMMA4_VIS_KEYS, M as parseKaniConfig, N as DEFAULT_GROUP_SIZE, O as kaniCosTensor, S as buildKaniLayerCosSin, T as generateKaniTtsGraph, a as PARLER_DAC_LATENT_DIM, b as KANI_START_OF_HUMAN, c as PARLER_SAMPLE_RATE, d as generateParlerEncoderGraph, f as parseParlerConfig, i as PARLER_DAC_DECODER_DIM, k as kaniLayerAlpha, l as buildT5RelativeBias, o as PARLER_DECODER_RATES, p as revertDelayPattern, r as PARLER_BOS_TOKEN_ID, s as PARLER_EOS_TOKEN_ID, u as generateParlerDecoderGraph, x as audioTokensToCodes, y as KANI_END_OF_HUMAN } from "./architectures-DmZMEFsA.mjs";
-import { C as createUniformBuffer, D as verifyGPU, E as initGPU, S as createStorageBuffer, T as getOrCreatePipeline, a as loadModel, b as clearPipelineCache, c as loadParlerTTS, d as remapPrunedToken, g as fetchAdapter, h as buildLoRADeltas, i as loadKaniTTS, l as quantizeBackboneInt4, p as Executor, r as createKeyMapperForArch, s as loadOuteTTS, u as quantizeKaniBackbone, v as KERNEL_REGISTRY, w as destroyBuffers, x as createBindGroup, y as MATMUL_BIAS_F16C_SPEC } from "./moonshine-stt-BXoZaHJE.mjs";
+import { A as kaniSinTensor, C as computeKaniPositions, D as kaniAttentionLayerIndices, E as generateNanoCodecDecoderGraph, F as CANONICAL_KEYS, I as DTYPE_BYTES, L as GEMMA4_VIS_KEYS, M as parseKaniConfig, N as DEFAULT_GROUP_SIZE, O as kaniCosTensor, S as buildKaniLayerCosSin, T as generateKaniTtsGraph, a as PARLER_DAC_LATENT_DIM, b as KANI_START_OF_HUMAN, c as PARLER_SAMPLE_RATE, d as generateParlerEncoderGraph, f as parseParlerConfig, i as PARLER_DAC_DECODER_DIM, k as kaniLayerAlpha, l as buildT5RelativeBias, o as PARLER_DECODER_RATES, p as revertDelayPattern, r as PARLER_BOS_TOKEN_ID, s as PARLER_EOS_TOKEN_ID, u as generateParlerDecoderGraph, x as audioTokensToCodes, y as KANI_END_OF_HUMAN } from "./architectures-BH_z6k9d.mjs";
+import { C as createUniformBuffer, D as verifyGPU, E as initGPU, S as createStorageBuffer, T as getOrCreatePipeline, a as loadModel, b as clearPipelineCache, c as loadParlerTTS, d as remapPrunedToken, g as fetchAdapter, h as buildLoRADeltas, i as loadKaniTTS, l as quantizeBackboneInt4, p as Executor, r as createKeyMapperForArch, s as loadOuteTTS, u as quantizeKaniBackbone, v as KERNEL_REGISTRY, w as destroyBuffers, x as createBindGroup, y as MATMUL_BIAS_F16C_SPEC } from "./moonshine-stt-B1kV5n1c.mjs";
 
 //#region src/gpu/architectures/gemma4_vision.ts
 /**
@@ -1225,6 +1225,571 @@ function cleanSuggestion(raw, typed, options = {}) {
 	return startsWithPunct || typedEndsWithSpace ? s : ` ${s}`;
 }
 
+//#endregion
+//#region src/gpu/sampler.ts
+/** mulberry32 — tiny deterministic PRNG for seeded sampling. */
+function mulberry32(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 | 0;
+		let t = Math.imul(a ^ a >>> 15, 1 | a);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Per-params seeded RNG streams (one stream per options object identity). */
+const seededStreams = /* @__PURE__ */ new WeakMap();
+function nextRandom(params) {
+	if (params.seed === void 0) return Math.random();
+	let rng = seededStreams.get(params);
+	if (!rng) {
+		rng = mulberry32(params.seed);
+		seededStreams.set(params, rng);
+	}
+	return rng();
+}
+let _heapIndices = null;
+let _heapValues = null;
+/**
+* Sample a token ID from logits.
+*
+* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
+*/
+function sampleToken(logits, params = {}, previousTokens) {
+	const temperature = params.temperature ?? .7;
+	const topK = params.topK ?? 50;
+	const topP = params.topP ?? .9;
+	const repetitionPenalty = params.repetitionPenalty ?? 1;
+	if (temperature < 1e-6) return argmax$2(logits);
+	const N = logits.length;
+	const K = Math.min(topK > 0 ? topK : N, N);
+	if (!_heapIndices || _heapIndices.length < K) {
+		_heapIndices = new Uint32Array(K);
+		_heapValues = new Float32Array(K);
+	}
+	const hIdx = _heapIndices;
+	const hVal = _heapValues;
+	let penaltySet = null;
+	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
+	let heapSize = 0;
+	for (let i = 0; i < N; i++) {
+		let s = logits[i];
+		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
+		s /= temperature;
+		if (heapSize < K) {
+			hIdx[heapSize] = i;
+			hVal[heapSize] = s;
+			heapSize++;
+			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
+		} else if (s > hVal[0]) {
+			hIdx[0] = i;
+			hVal[0] = s;
+			siftDown(hIdx, hVal, 0, K);
+		}
+	}
+	for (let i = 1; i < heapSize; i++) {
+		const vi = hVal[i];
+		const ii = hIdx[i];
+		let j = i - 1;
+		while (j >= 0 && hVal[j] < vi) {
+			hVal[j + 1] = hVal[j];
+			hIdx[j + 1] = hIdx[j];
+			j--;
+		}
+		hVal[j + 1] = vi;
+		hIdx[j + 1] = ii;
+	}
+	const maxScore = hVal[0];
+	let sumExp = 0;
+	for (let i = 0; i < heapSize; i++) {
+		const p = Math.exp(hVal[i] - maxScore);
+		hVal[i] = p;
+		sumExp += p;
+	}
+	const invSum = 1 / sumExp;
+	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
+	let candidateCount = heapSize;
+	if (topP < 1) {
+		let cumulative$1 = 0;
+		for (let i = 0; i < heapSize; i++) {
+			cumulative$1 += hVal[i];
+			if (cumulative$1 >= topP) {
+				candidateCount = i + 1;
+				break;
+			}
+		}
+		let sum = 0;
+		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
+		const inv = 1 / sum;
+		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
+	}
+	const r = nextRandom(params);
+	let cumulative = 0;
+	for (let i = 0; i < candidateCount; i++) {
+		cumulative += hVal[i];
+		if (r <= cumulative) return hIdx[i];
+	}
+	return hIdx[candidateCount - 1];
+}
+/**
+* Return the index of the maximum value (greedy decoding).
+*/
+function argmax$2(arr) {
+	let maxIdx = 0;
+	let maxVal = arr[0];
+	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
+		maxVal = arr[i];
+		maxIdx = i;
+	}
+	return maxIdx;
+}
+/** Min-heap sift down on parallel index/value typed arrays. */
+function siftDown(indices, values, i, n) {
+	while (true) {
+		let smallest = i;
+		const left = 2 * i + 1;
+		const right = 2 * i + 2;
+		if (left < n && values[left] < values[smallest]) smallest = left;
+		if (right < n && values[right] < values[smallest]) smallest = right;
+		if (smallest === i) break;
+		const ti = indices[i];
+		indices[i] = indices[smallest];
+		indices[smallest] = ti;
+		const tv = values[i];
+		values[i] = values[smallest];
+		values[smallest] = tv;
+		i = smallest;
+	}
+}
+
+//#endregion
+//#region src/gpu/batch/scheduler.ts
+const PIPELINE_DEPTH = 2;
+var RequestScheduler = class {
+	host;
+	batchSize;
+	maxSeqLen;
+	blockSize;
+	prefillChunk;
+	/** Free KV blocks kept unreserved as safety headroom. */
+	blockHeadroom;
+	nextId = 1;
+	queue = [];
+	/** slot → occupying request (prefilling or decoding). */
+	slots;
+	/** Sum of blocksReserved across live (admitted, unfinished) requests. */
+	reservedBlocks = 0;
+	prefilling = null;
+	inFlight = [];
+	/**
+	* The slot→adapter-id assignment last uploaded to the executor (null =
+	* nothing uploaded this batch session). Steps only re-upload when the
+	* assignment changes (admissions/retirements), and the very first upload is
+	* skipped entirely while every lane is bare base — an adapter-free serving
+	* session never touches the LoRA machinery.
+	*/
+	lastLaneAdapterIds = null;
+	stepCounter = 0;
+	loop = null;
+	closed = false;
+	stats = {
+		submitted: 0,
+		completed: 0,
+		stepsSubmitted: 0,
+		prefillChunks: 0,
+		tokensGenerated: 0,
+		busyMs: 0,
+		peakActiveLanes: 0
+	};
+	constructor(host, options = {}) {
+		this.host = host;
+		this.batchSize = host.executor.batchSize;
+		if (this.batchSize <= 0) throw new Error("RequestScheduler requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		this.maxSeqLen = host.executor.maxSequenceLength;
+		this.blockSize = host.executor.kvBlockSizeTokens;
+		this.slots = new Array(this.batchSize).fill(null);
+		const envChunk = typeof process !== "undefined" ? Number(process.env?.GERBIL_PREFILL_CHUNK) : NaN;
+		this.prefillChunk = options.prefillChunkTokens ?? (Number.isFinite(envChunk) && envChunk >= 8 ? envChunk : 128);
+		this.blockHeadroom = 2;
+	}
+	/**
+	* Submit a request; resolves with the full result when it finishes.
+	* Tokens stream through options.onToken as they are decoded.
+	*/
+	submit(prompt, options = {}) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler is closed"));
+		if ((options.sampling?.temperature ?? 0) >= 1e-6) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler: Phase 5 is greedy-only — pass sampling: { temperature: 0 }"));
+		let adapterReg = null;
+		if (options.adapter != null) {
+			if (!this.host.executor.batchLoraEnabled) return Promise.reject(/* @__PURE__ */ new Error("RequestScheduler: per-request adapters require GERBIL_BATCH_LORA=1 (with GERBIL_BATCH=N)"));
+			try {
+				adapterReg = this.host.resolveAdapter(options.adapter);
+			} catch (err) {
+				return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		}
+		const messages = typeof prompt === "string" ? [...options.systemPrompt ? [{
+			role: "system",
+			content: options.systemPrompt
+		}] : [], {
+			role: "user",
+			content: prompt
+		}] : options.systemPrompt ? [{
+			role: "system",
+			content: options.systemPrompt
+		}, ...prompt] : prompt;
+		const promptIds = new Uint32Array(this.host.encodeChat(messages));
+		const roomFor = this.maxSeqLen - promptIds.length - PIPELINE_DEPTH - 1;
+		if (roomFor < 1) return Promise.reject(/* @__PURE__ */ new Error(`RequestScheduler: prompt (${promptIds.length} tokens) leaves no room in maxSeqLen ${this.maxSeqLen}`));
+		const maxTokens = Math.min(options.maxTokens ?? 128, roomFor);
+		return new Promise((resolve, reject) => {
+			const req = {
+				id: this.nextId++,
+				promptIds,
+				maxTokens,
+				stopSequences: options.stopSequences ?? [],
+				adapterName: options.adapter ?? null,
+				adapterId: adapterReg?.id ?? -1,
+				adapterDeltas: adapterReg?.deltas ?? null,
+				onToken: options.onToken,
+				resolve,
+				reject,
+				state: "queued",
+				slot: -1,
+				prefillPos: 0,
+				blocksReserved: 0,
+				generatedIds: [],
+				text: "",
+				finishReason: "max_tokens",
+				submittedAt: performance.now(),
+				admittedAt: 0,
+				firstTokenAt: 0
+			};
+			this.queue.push(req);
+			this.stats.submitted++;
+			this.pump();
+		});
+	}
+	/** Resolves when every submitted request has completed. */
+	async drain() {
+		while (this.loop) await this.loop;
+	}
+	/** Stop accepting requests; resolves when in-flight work drains. */
+	async close() {
+		this.closed = true;
+		await this.drain();
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+	pump() {
+		if (this.loop) return;
+		this.loop = this.run().finally(() => {
+			this.loop = null;
+			if (this.hasWork()) this.pump();
+		});
+	}
+	hasWork() {
+		return this.queue.length > 0 || this.prefilling !== null || this.inFlight.length > 0 || this.slots.some((s) => s !== null);
+	}
+	activeMask() {
+		const mask = new Uint8Array(this.batchSize);
+		const rows = [];
+		for (let b = 0; b < this.batchSize; b++) {
+			const req = this.slots[b];
+			if (req && req.state === "decoding") {
+				mask[b] = 1;
+				rows.push({
+					slot: b,
+					req
+				});
+			}
+		}
+		return {
+			mask,
+			rows
+		};
+	}
+	/** The serving loop. Holds the engine generation lock while live. */
+	async run() {
+		const release = await this.host.acquireLock();
+		const ex = this.host.executor;
+		const loopStart = performance.now();
+		ex.resetBatch();
+		this.stepCounter = 0;
+		this.lastLaneAdapterIds = null;
+		try {
+			while (this.hasWork()) {
+				this.admit();
+				const { mask, rows } = this.activeMask();
+				if (rows.length > 0 && this.inFlight.length < PIPELINE_DEPTH) {
+					const readbackSlot = this.stepCounter % PIPELINE_DEPTH;
+					this.syncLaneAdapters();
+					ex.submitBatchDecodeStepMasked(mask, readbackSlot);
+					this.stepCounter++;
+					this.inFlight.push({
+						readbackSlot,
+						rows
+					});
+					this.stats.stepsSubmitted++;
+					if (rows.length > this.stats.peakActiveLanes) this.stats.peakActiveLanes = rows.length;
+				}
+				if (this.prefilling) await this.prefillChunkStep();
+				const pipelineFull = this.inFlight.length >= PIPELINE_DEPTH;
+				const idleLanes = rows.length === 0 && this.prefilling === null;
+				if (this.inFlight.length > 0 && (pipelineFull || idleLanes)) await this.readStep();
+			}
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (this.prefilling?.adapterDeltas) try {
+				ex.clearRuntimeLoRA();
+			} catch {}
+			for (const req of [...this.queue, ...this.slots.filter((s) => s !== null)]) if (req.state !== "done") {
+				req.state = "done";
+				req.reject(error);
+			}
+			this.queue = [];
+			this.slots.fill(null);
+			this.prefilling = null;
+			this.inFlight = [];
+			this.reservedBlocks = 0;
+			throw error;
+		} finally {
+			this.stats.busyMs += performance.now() - loopStart;
+			release();
+		}
+	}
+	/**
+	* Upload the slot→adapter assignment for the step about to be submitted,
+	* when it differs from the last uploaded one. Called immediately before
+	* every decode-step submit: `queue.writeBuffer` is queue-ordered, so steps
+	* already in flight keep the assignment they were submitted under, and a
+	* retiring lane's slot can never leak its adapter into the slot's next
+	* occupant — the next occupant's assignment is re-derived from `slots`
+	* before its first decode step. Masked (free/prefilling) lanes are pinned
+	* to bare base; their output is discarded regardless.
+	*/
+	syncLaneAdapters() {
+		if (!this.host.executor.batchLoraEnabled) return;
+		const ids = new Int32Array(this.batchSize).fill(-1);
+		let anyAdapter = false;
+		for (let b = 0; b < this.batchSize; b++) {
+			const req = this.slots[b];
+			if (req && req.state === "decoding" && req.adapterId >= 0) {
+				ids[b] = req.adapterId;
+				anyAdapter = true;
+			}
+		}
+		const last = this.lastLaneAdapterIds;
+		if (last === null) {
+			if (!anyAdapter) return;
+		} else if (ids.every((id, b) => id === last[b])) return;
+		this.host.executor.setBatchLaneAdapters(ids);
+		this.lastLaneAdapterIds = ids;
+	}
+	/**
+	* Admission: move the next queued request into a free slot when (a) a slot
+	* is free, (b) no other prefill is staged (the single-sequence prefill path
+	* stages SSM state in singleton buffers — one at a time), and (c) its
+	* worst-case block need fits the unreserved KV pool with headroom.
+	*/
+	admit() {
+		if (this.prefilling || this.queue.length === 0) return;
+		const slot = this.slots.indexOf(null);
+		if (slot === -1) return;
+		const req = this.queue[0];
+		const worstTokens = req.promptIds.length + req.maxTokens + PIPELINE_DEPTH;
+		const blocksNeeded = Math.ceil(worstTokens / this.blockSize);
+		const totalBlocks = this.host.executor.kvTotalBlocks;
+		if (this.reservedBlocks + blocksNeeded + this.blockHeadroom > totalBlocks) return;
+		this.queue.shift();
+		req.state = "prefilling";
+		req.slot = slot;
+		req.blocksReserved = blocksNeeded;
+		req.admittedAt = performance.now();
+		this.reservedBlocks += blocksNeeded;
+		this.slots[slot] = req;
+		this.prefilling = req;
+		if (req.adapterDeltas) {
+			const { applied } = this.host.executor.applyRuntimeLoRA(req.adapterDeltas);
+			if (applied === 0) throw new Error(`RequestScheduler: adapter "${req.adapterName}" resolved to 0 applicable prefill targets`);
+		}
+		this.host.executor.beginBatchSlot(slot);
+	}
+	/**
+	* Run one bounded prefill chunk for the staged request on the
+	* single-sequence path (into its slot's block-table row via tableBase).
+	* Intermediate chunks are submit-only; the final chunk reads logits, adopts
+	* the singleton SSM state into the slot's pool row, seeds the lane's first
+	* token, and flips the lane to decoding.
+	*/
+	async prefillChunkStep() {
+		const req = this.prefilling;
+		if (!req) return;
+		const ex = this.host.executor;
+		const end = Math.min(req.prefillPos + this.prefillChunk, req.promptIds.length);
+		const isLast = end === req.promptIds.length;
+		const chunk = req.promptIds.subarray(req.prefillPos, end);
+		const { logits } = await ex.forward(chunk, { readLogits: isLast });
+		req.prefillPos = end;
+		this.stats.prefillChunks++;
+		if (!isLast) return;
+		ex.finishBatchSlot(req.slot);
+		if (req.adapterDeltas) ex.clearRuntimeLoRA();
+		this.prefilling = null;
+		const first = this.host.remapToken(sampleToken(logits, { temperature: 0 }));
+		ex.injectBatchToken(req.slot, first);
+		req.state = "decoding";
+		req.firstTokenAt = performance.now();
+		this.consumeToken(req, first);
+	}
+	/** Read the oldest in-flight step and deliver its tokens. */
+	async readStep() {
+		const step = this.inFlight.shift();
+		if (!step) return;
+		const tokens = await this.host.executor.readBatchTokens(step.readbackSlot);
+		for (const { slot, req } of step.rows) {
+			if (this.slots[slot] !== req || req.state !== "decoding") continue;
+			this.consumeToken(req, tokens[slot]);
+		}
+	}
+	/** Append one generated token; finish + retire the lane when terminal. */
+	consumeToken(req, tokenId) {
+		req.generatedIds.push(tokenId);
+		this.stats.tokensGenerated++;
+		if (req.firstTokenAt === 0) req.firstTokenAt = performance.now();
+		const { eosTokenId, eotTokenId } = this.host;
+		if (eosTokenId !== null && tokenId === eosTokenId || eotTokenId !== null && tokenId === eotTokenId) {
+			req.finishReason = "eos";
+			this.finish(req);
+			return;
+		}
+		const piece = this.host.decodeToken(tokenId);
+		req.text += piece;
+		if (req.stopSequences.some((s) => req.text.includes(s))) {
+			for (const s of req.stopSequences) {
+				const idx = req.text.indexOf(s);
+				if (idx !== -1) req.text = req.text.slice(0, idx);
+			}
+			req.finishReason = "stop_sequence";
+			this.finish(req);
+			return;
+		}
+		req.onToken?.(piece, {
+			requestId: req.id,
+			tokenId,
+			generated: req.generatedIds.length
+		});
+		if (req.generatedIds.length >= req.maxTokens) {
+			req.finishReason = "max_tokens";
+			this.finish(req);
+		}
+	}
+	/** Retire the lane immediately: free KV blocks, open the slot, resolve. */
+	finish(req) {
+		req.state = "done";
+		if (req.slot >= 0 && this.slots[req.slot] === req) {
+			this.host.executor.retireBatchSlot(req.slot);
+			this.slots[req.slot] = null;
+		}
+		this.reservedBlocks -= req.blocksReserved;
+		this.stats.completed++;
+		const finishedAt = performance.now();
+		req.resolve({
+			requestId: req.id,
+			text: req.text,
+			tokenIds: [...req.generatedIds],
+			tokensGenerated: req.generatedIds.length,
+			finishReason: req.finishReason,
+			adapter: req.adapterName ?? void 0,
+			submittedAt: req.submittedAt,
+			admittedAt: req.admittedAt,
+			firstTokenAt: req.firstTokenAt,
+			finishedAt,
+			ttftMs: req.firstTokenAt - req.submittedAt,
+			e2eMs: finishedAt - req.submittedAt
+		});
+	}
+};
+
+//#endregion
+//#region src/gpu/batch/swarm.ts
+/** Default reduce: member-keyed map, disambiguating duplicated members. */
+function reduceToKeyedMap(results) {
+	const out = {};
+	const seen = /* @__PURE__ */ new Map();
+	for (const { member, result } of results) {
+		const n = (seen.get(member) ?? 0) + 1;
+		seen.set(member, n);
+		out[n === 1 ? member : `${member}#${n}`] = result;
+	}
+	return out;
+}
+/**
+* A swarm handle: registered members + plan/reduce over the engine's
+* scheduler. Create via {@link WebGPUEngine.createSwarm}.
+*/
+var Swarm = class {
+	scheduler;
+	memberSources;
+	plan;
+	reduce;
+	constructor(scheduler, options) {
+		if (Object.keys(options.members).length === 0) throw new Error("Swarm: members must contain at least one member");
+		this.scheduler = scheduler;
+		this.memberSources = { ...options.members };
+		this.plan = options.plan;
+		this.reduce = options.reduce;
+	}
+	/** Member names, declaration order. */
+	get members() {
+		return Object.keys(this.memberSources);
+	}
+	/**
+	* Run one input through the swarm: plan → concurrent fan-out (one batched
+	* pass across the scheduler's lanes) → reduce.
+	*
+	* @param input The task input handed to the plan (default plan: broadcast
+	*   it to every member as the prompt).
+	* @param options Per-request options applied to every sub-task (a task's
+	*   own `options` win field-by-field).
+	*/
+	async run(input, options = {}) {
+		const tasks = this.plan ? await this.plan(input, this.members) : this.members.map((member) => ({
+			member,
+			prompt: input
+		}));
+		if (tasks.length === 0) throw new Error("Swarm: plan produced no sub-tasks");
+		const results = await Promise.all(tasks.map(async (task) => {
+			const result = await this.submitFor(task.member, task.prompt, {
+				...options,
+				...task.options
+			});
+			return {
+				member: task.member,
+				result
+			};
+		}));
+		if (this.reduce) return this.reduce(results);
+		return reduceToKeyedMap(results);
+	}
+	/**
+	* Mode-A access: decode one prompt with a single member (no plan/reduce).
+	* Still rides the shared scheduler, so it batches with any concurrent work.
+	*/
+	generate(member, prompt, options = {}) {
+		return this.submitFor(member, prompt, options);
+	}
+	submitFor(member, prompt, options) {
+		if (!Object.hasOwn(this.memberSources, member)) throw new Error(`Swarm: unknown member "${member}" (members: ${this.members.join(", ")})`);
+		const adapter = this.memberSources[member] == null ? void 0 : member;
+		return this.scheduler.submit(prompt, {
+			...options,
+			adapter
+		});
+	}
+};
+
 //#endregion
 //#region src/gpu/architectures/outetts.ts
 const OUTETTS_C1_BASE = 151669;
@@ -2859,7 +3424,7 @@ function selectGraphWeights$1(graph, weights) {
 	return out;
 }
 /** Index of the maximum logit (greedy / argmax decode). */
-function argmax$2(logits) {
+function argmax$1(logits) {
 	let best = 0;
 	let bestV = logits[0];
 	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
@@ -3188,7 +3753,7 @@ var OuteTTS = class OuteTTS {
 		const generated = [];
 		let logits = prefillLogits;
 		for (let step = 0; step < p.maxNewTokens; step++) {
-			const next = p.greedy ? argmax$2(logits) : this.sampleToken(logits, {
+			const next = p.greedy ? argmax$1(logits) : this.sampleToken(logits, {
 				temperature: p.temperature,
 				topP: p.topP,
 				topK: p.topK,
@@ -3320,7 +3885,7 @@ function selectGraphWeights(graph, weights) {
 	return out;
 }
 /** Argmax over a logit row. */
-function argmax$1(logits) {
+function argmax(logits) {
 	let best = 0;
 	let bestV = logits[0];
 	for (let i = 1; i < logits.length; i++) if (logits[i] > bestV) {
@@ -3671,7 +4236,7 @@ var ParlerTTS = class ParlerTTS {
 						continue;
 					}
 					if (cb > frontier) logitRows[cb][PARLER_EOS_TOKEN_ID] = Number.NEGATIVE_INFINITY;
-					const code = opts.greedy ? argmax$1(logitRows[cb]) : sampleLogits(logitRows[cb], opts.temperature ?? 1, opts.topK ?? 0);
+					const code = opts.greedy ? argmax(logitRows[cb]) : sampleLogits(logitRows[cb], opts.temperature ?? 1, opts.topK ?? 0);
 					nextCodes[cb] = code;
 					grid[cb * maxSteps + step] = code < PARLER_CODEBOOK_SIZE ? code : 0;
 				}
@@ -3742,122 +4307,6 @@ function addPosition(row, posTable, pos, H) {
 	for (let i = 0; i < H; i++) row[i] += posTable[base + i];
 }
 
-//#endregion
-//#region src/gpu/sampler.ts
-let _heapIndices = null;
-let _heapValues = null;
-/**
-* Sample a token ID from logits.
-*
-* Pipeline: repetition penalty → temperature → top-k (min-heap) → softmax → top-p → sample.
-*/
-function sampleToken(logits, params = {}, previousTokens) {
-	const temperature = params.temperature ?? .7;
-	const topK = params.topK ?? 50;
-	const topP = params.topP ?? .9;
-	const repetitionPenalty = params.repetitionPenalty ?? 1;
-	if (temperature < 1e-6) return argmax(logits);
-	const N = logits.length;
-	const K = Math.min(topK > 0 ? topK : N, N);
-	if (!_heapIndices || _heapIndices.length < K) {
-		_heapIndices = new Uint32Array(K);
-		_heapValues = new Float32Array(K);
-	}
-	const hIdx = _heapIndices;
-	const hVal = _heapValues;
-	let penaltySet = null;
-	if (repetitionPenalty !== 1 && previousTokens?.length) penaltySet = new Set(previousTokens);
-	let heapSize = 0;
-	for (let i = 0; i < N; i++) {
-		let s = logits[i];
-		if (penaltySet?.has(i)) s = s > 0 ? s / repetitionPenalty : s * repetitionPenalty;
-		s /= temperature;
-		if (heapSize < K) {
-			hIdx[heapSize] = i;
-			hVal[heapSize] = s;
-			heapSize++;
-			if (heapSize === K) for (let j = (K >> 1) - 1; j >= 0; j--) siftDown(hIdx, hVal, j, K);
-		} else if (s > hVal[0]) {
-			hIdx[0] = i;
-			hVal[0] = s;
-			siftDown(hIdx, hVal, 0, K);
-		}
-	}
-	for (let i = 1; i < heapSize; i++) {
-		const vi = hVal[i];
-		const ii = hIdx[i];
-		let j = i - 1;
-		while (j >= 0 && hVal[j] < vi) {
-			hVal[j + 1] = hVal[j];
-			hIdx[j + 1] = hIdx[j];
-			j--;
-		}
-		hVal[j + 1] = vi;
-		hIdx[j + 1] = ii;
-	}
-	const maxScore = hVal[0];
-	let sumExp = 0;
-	for (let i = 0; i < heapSize; i++) {
-		const p = Math.exp(hVal[i] - maxScore);
-		hVal[i] = p;
-		sumExp += p;
-	}
-	const invSum = 1 / sumExp;
-	for (let i = 0; i < heapSize; i++) hVal[i] *= invSum;
-	let candidateCount = heapSize;
-	if (topP < 1) {
-		let cumulative$1 = 0;
-		for (let i = 0; i < heapSize; i++) {
-			cumulative$1 += hVal[i];
-			if (cumulative$1 >= topP) {
-				candidateCount = i + 1;
-				break;
-			}
-		}
-		let sum = 0;
-		for (let i = 0; i < candidateCount; i++) sum += hVal[i];
-		const inv = 1 / sum;
-		for (let i = 0; i < candidateCount; i++) hVal[i] *= inv;
-	}
-	const r = Math.random();
-	let cumulative = 0;
-	for (let i = 0; i < candidateCount; i++) {
-		cumulative += hVal[i];
-		if (r <= cumulative) return hIdx[i];
-	}
-	return hIdx[candidateCount - 1];
-}
-/**
-* Return the index of the maximum value (greedy decoding).
-*/
-function argmax(arr) {
-	let maxIdx = 0;
-	let maxVal = arr[0];
-	for (let i = 1; i < arr.length; i++) if (arr[i] > maxVal) {
-		maxVal = arr[i];
-		maxIdx = i;
-	}
-	return maxIdx;
-}
-/** Min-heap sift down on parallel index/value typed arrays. */
-function siftDown(indices, values, i, n) {
-	while (true) {
-		let smallest = i;
-		const left = 2 * i + 1;
-		const right = 2 * i + 2;
-		if (left < n && values[left] < values[smallest]) smallest = left;
-		if (right < n && values[right] < values[smallest]) smallest = right;
-		if (smallest === i) break;
-		const ti = indices[i];
-		indices[i] = indices[smallest];
-		indices[smallest] = ti;
-		const tv = values[i];
-		values[i] = values[smallest];
-		values[smallest] = tv;
-		i = smallest;
-	}
-}
-
 //#endregion
 //#region src/gpu/vision-executor.ts
 const MAP_MODE_READ = 1;
@@ -5143,8 +5592,12 @@ var WebGPUEngine = class WebGPUEngine {
 	_outeVoice = null;
 	/** Source of the runtime LoRA adapter currently applied on the static base, if any. */
 	_currentAdapter = null;
+	/** Named adapters registered for per-lane batched decode (GERBIL_BATCH_LORA). */
+	_batchAdapters = /* @__PURE__ */ new Map();
 	/** Lazily-created Parler-TTS engine (Flan-T5 encoder + decoder LM + dac_44khz). */
 	_parlerTTS = null;
+	/** Lazily-created continuous-batching scheduler (GERBIL_BATCH, Phase 5). */
+	_scheduler = null;
 	/**
 	* WebKit group-size probe state. When true, a candidate group size is being
 	* tried this page-load and must be promoted (or capped) after the FIRST
@@ -5250,6 +5703,35 @@ var WebGPUEngine = class WebGPUEngine {
 		return this._currentAdapter;
 	}
 	/**
+	* Register a named LoRA adapter for per-lane batched decode (SGMV phase 1,
+	* `GERBIL_BATCH=N` + `GERBIL_BATCH_LORA=1`). The adapter's factors are
+	* fetched and packed into the executor's shared factor buffers ONCE; any
+	* number of batch lanes can then run it concurrently by passing its name in
+	* `generateBatch`'s per-lane `adapters` option. Registering the same name
+	* twice is a no-op.
+	*/
+	async registerAdapter(name, source) {
+		this.checkDestroyed();
+		if (!this.executor.batchLoraEnabled) throw new Error("registerAdapter requires GERBIL_BATCH=N (N >= 2) and GERBIL_BATCH_LORA=1 on the Dawn path");
+		if (this._batchAdapters.has(name)) return;
+		const adapter = await fetchAdapter(source, {
+			hfToken: this._createOptions.hfToken,
+			revision: this._createOptions.revision
+		});
+		if (!adapter) throw new Error(`No adapter found at ${source}.`);
+		const deltas = buildLoRADeltas(adapter, createKeyMapperForArch(this._architecture));
+		const id = this.executor.registerBatchAdapter(deltas);
+		this._batchAdapters.set(name, {
+			id,
+			deltas
+		});
+		console.log(`[engine] batch adapter "${name}" (${source}) registered as id ${id}.`);
+	}
+	/** Names of the adapters registered for per-lane batched decode. */
+	getRegisteredAdapters() {
+		return [...this._batchAdapters.keys()];
+	}
+	/**
 	* Write a coarse crash-phase breadcrumb that survives a GPU-process kill / page
 	* reload. The iPad harness reads `localStorage["gerbil-crash-phase"]` after a
 	* crash; without these, a describe-time crash only shows the last load phase
@@ -5580,6 +6062,186 @@ var WebGPUEngine = class WebGPUEngine {
 		}
 	}
 	/**
+	* Batched lockstep generation (GERBIL_BATCH=N — Phase 2 of the
+	* continuous-batching campaign, Dawn only).
+	*
+	* Prefills each prompt sequentially into its batch slot (KV into the slot's
+	* block-table row, SSM/conv state adopted into the slot's state-pool rows),
+	* then decodes all N sequences in lockstep: one batched dispatch stream per
+	* step produces one token per row. Greedy-only in Phase 2 (per-row GPU
+	* argmax); rows that hit EOS/stop keep decoding in lockstep with their
+	* output discarded until every row has finished — rows never interact, so
+	* per-row streams are token-exact vs single-sequence generation.
+	*
+	* Requires exactly `executor.batchSize` prompts (fixed lockstep batch; the
+	* Phase 3 scheduler will lift this).
+	*/
+	async generateBatch(prompts, options = {}) {
+		this.checkDestroyed();
+		const B = this.executor.batchSize;
+		if (B <= 0) throw new Error("generateBatch requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		if (prompts.length !== B) throw new Error(`generateBatch: got ${prompts.length} prompts for a fixed batch of ${B} (set GERBIL_BATCH=${prompts.length})`);
+		if (this._multimodalGraph || this.executor.hasPleSource() || this.executor.hasRuntimeAdapter) throw new Error("generateBatch: multimodal, PLE, and runtime-LoRA models are Phase 2+ work");
+		const { maxTokens = 512, stopSequences = [], sampling = {}, systemPrompt } = options;
+		if ((sampling.temperature ?? .7) >= 1e-6) throw new Error("generateBatch: Phase 2 is greedy-only — pass sampling: { temperature: 0 }");
+		const laneAdapterNames = options.adapters;
+		if (laneAdapterNames && laneAdapterNames.length !== B) throw new Error(`generateBatch: got ${laneAdapterNames.length} lane adapters for a batch of ${B}`);
+		if ((laneAdapterNames?.some((a) => a != null) ?? false) && !this.executor.batchLoraEnabled) throw new Error("generateBatch: per-lane adapters require GERBIL_BATCH_LORA=1");
+		const laneAdapters = new Array(B).fill(null);
+		if (laneAdapterNames) for (let i = 0; i < B; i++) {
+			const name = laneAdapterNames[i];
+			if (name == null) continue;
+			const reg = this._batchAdapters.get(name);
+			if (!reg) throw new Error(`generateBatch: adapter "${name}" not registered (call registerAdapter first)`);
+			laneAdapters[i] = reg;
+		}
+		const release = await this._acquireGenLock();
+		try {
+			const startTime = performance.now();
+			this.executor.resetBatch();
+			const eosId = this.tokenizer.config.eosTokenId;
+			const eotId = this.resolveEndOfTurnId();
+			const keepPlan = this.config.vocabKeepPlan;
+			const remapTok = keepPlan ? (i) => remapPrunedToken(i, keepPlan) : (i) => i;
+			const rows = prompts.map((_p, i) => ({
+				generatedIds: [],
+				text: "",
+				finished: false,
+				finishReason: "max_tokens",
+				limit: options.maxTokensPerRow?.[i] ?? maxTokens
+			}));
+			const firstTokens = new Uint32Array(B);
+			for (let i = 0; i < B; i++) {
+				const p = prompts[i];
+				const messages = typeof p === "string" ? [...systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}] : [], {
+					role: "user",
+					content: p
+				}] : systemPrompt ? [{
+					role: "system",
+					content: systemPrompt
+				}, ...p] : p;
+				const inputIds = this.tokenizer.encodeChat(messages, { addGenerationPrompt: true });
+				const laneReg = laneAdapters[i];
+				if (laneReg) this.executor.applyRuntimeLoRA(laneReg.deltas);
+				try {
+					this.executor.beginBatchSlot(i);
+					const { logits } = await this.executor.forward(new Uint32Array(inputIds));
+					this.executor.finishBatchSlot(i);
+					firstTokens[i] = remapTok(sampleToken(logits, { temperature: 0 }));
+				} finally {
+					if (laneReg) this.executor.clearRuntimeLoRA();
+				}
+			}
+			if (this.executor.batchLoraEnabled) this.executor.setBatchLaneAdapters(laneAdapters.map((a) => a ? a.id : -1));
+			const consume = (row, tok) => {
+				if (row.finished) return;
+				row.generatedIds.push(tok);
+				if (eosId !== null && tok === eosId || eotId !== null && tok === eotId) {
+					row.finished = true;
+					row.finishReason = "eos";
+					return;
+				}
+				row.text += this.tokenizer.decode([tok], true);
+				if (stopSequences.some((s) => row.text.includes(s))) {
+					for (const s of stopSequences) {
+						const idx = row.text.indexOf(s);
+						if (idx !== -1) row.text = row.text.slice(0, idx);
+					}
+					row.finished = true;
+					row.finishReason = "stop_sequence";
+					return;
+				}
+				if (row.generatedIds.length >= row.limit) row.finished = true;
+			};
+			const decodeStart = performance.now();
+			for (let i = 0; i < B; i++) consume(rows[i], firstTokens[i]);
+			const depth = Executor.PIPELINE_DEPTH;
+			const lens = this.executor.batchSlotLengths;
+			let capacity = Number.POSITIVE_INFINITY;
+			for (let i = 0; i < B; i++) capacity = Math.min(capacity, this.maxSeqLen - lens[i] - 1);
+			const maxRowLimit = rows.reduce((a, r) => Math.max(a, r.limit), 0);
+			const stepsNeeded = Math.max(0, Math.min(maxRowLimit - 1, capacity));
+			let submitted = 0;
+			let consumedSteps = 0;
+			while (consumedSteps < stepsNeeded && !rows.every((r) => r.finished)) {
+				while (submitted < stepsNeeded && submitted < consumedSteps + depth) {
+					this.executor.submitBatchDecodeStep(submitted === 0 ? firstTokens : null, submitted % depth);
+					submitted++;
+				}
+				const toks = await this.executor.readBatchTokens(consumedSteps % depth);
+				consumedSteps++;
+				for (let i = 0; i < B; i++) consume(rows[i], toks[i]);
+			}
+			const decodeTime = performance.now() - decodeStart;
+			const totalTime = performance.now() - startTime;
+			return rows.map((r) => ({
+				text: r.text,
+				tokensGenerated: r.generatedIds.length,
+				tokensPerSecond: r.generatedIds.length / (totalTime / 1e3),
+				totalTime,
+				decodeTime,
+				finishReason: r.finishReason,
+				tokenIds: [...r.generatedIds]
+			}));
+		} finally {
+			release();
+		}
+	}
+	/**
+	* Continuous-batching scheduler (GERBIL_BATCH=N — Phase 5 of the batching
+	* campaign, Dawn only). Returns the engine's request scheduler (created on
+	* first call): submit many requests with independent prompts/limits and the
+	* scheduler multiplexes them over the batch lanes with dynamic admission,
+	* immediate lane retirement, and chunked prefill. Greedy-only; per-request
+	* output is token-exact vs single-sequence generate().
+	*/
+	createScheduler() {
+		this.checkDestroyed();
+		if (this._scheduler) return this._scheduler;
+		if (this.executor.batchSize <= 0) throw new Error("createScheduler requires GERBIL_BATCH=N (N >= 2) on the Dawn path");
+		if (this._multimodalGraph || this.executor.hasPleSource() || this.executor.hasRuntimeAdapter) throw new Error("createScheduler: multimodal, PLE, and runtime-LoRA models are unsupported");
+		const keepPlan = this.config.vocabKeepPlan;
+		this._scheduler = new RequestScheduler({
+			executor: this.executor,
+			encodeChat: (messages) => this.tokenizer.encodeChat(messages, { addGenerationPrompt: true }),
+			decodeToken: (id) => this.tokenizer.decode([id], true),
+			eosTokenId: this.tokenizer.config.eosTokenId,
+			eotTokenId: this.resolveEndOfTurnId(),
+			remapToken: keepPlan ? (i) => remapPrunedToken(i, keepPlan) : (i) => i,
+			resolveAdapter: (name) => {
+				const reg = this._batchAdapters.get(name);
+				if (!reg) throw new Error(`scheduler: adapter "${name}" not registered (call registerAdapter first)`);
+				return reg;
+			},
+			acquireLock: () => this._acquireGenLock()
+		});
+		return this._scheduler;
+	}
+	/**
+	* Create a swarm — the MoTA mode-B primitive (docs/research/slm-swarms.md):
+	* named members (LoRA adapters on this engine's shared base, or null for the
+	* bare base), an optional plan that fans an input out into per-member
+	* sub-tasks, and an optional reduce that joins the results. `swarm.run()`
+	* decodes every sub-task CONCURRENTLY through the continuous-batching
+	* scheduler with per-request adapters — one batched pass, so the fan-out
+	* costs roughly the slowest member, not the sum.
+	*
+	* Every non-null member source is registered via {@link registerAdapter}
+	* (downloads in parallel; factors packed into shared GPU buffers once).
+	* Requires `GERBIL_BATCH=N` (N >= 2) + `GERBIL_BATCH_LORA=1` on the Dawn
+	* path; greedy-only like the scheduler underneath.
+	*/
+	async createSwarm(options) {
+		this.checkDestroyed();
+		if (!this.executor.batchLoraEnabled) throw new Error("createSwarm requires GERBIL_BATCH=N (N >= 2) and GERBIL_BATCH_LORA=1 on the Dawn path");
+		const scheduler = this.createScheduler();
+		await Promise.all(Object.entries(options.members).map(([name, source]) => source == null ? Promise.resolve() : this.registerAdapter(name, source)));
+		return new Swarm(scheduler, options);
+	}
+	/**
 	* Resolve the end-of-turn stop token id, or null if the model has none.
 	*
 	* Chat models like Gemma 4 end an assistant turn with a dedicated end-of-turn
@@ -5665,18 +6327,34 @@ var WebGPUEngine = class WebGPUEngine {
 		if (isGreedy && !this.executor.needsMultiEncoder && !mmDecode && !streamsPle) {
 			const firstToken = remapTok(sampleToken(logits, sampling, [...inputIds, ...generatedIds]));
 			if (!consumeToken(firstToken)) {
-				const depth = Executor.PIPELINE_DEPTH;
 				const stepsNeeded = Math.min(maxTokens - 1, this.executor.decodeCapacityRemaining());
-				let submitted = 0;
-				let consumed = 0;
-				while (consumed < stepsNeeded) {
-					while (submitted < stepsNeeded && submitted < consumed + depth) {
-						this.executor.submitGreedyDecodeStep(submitted === 0 ? firstToken : null, submitted % depth);
-						submitted++;
+				const windowK = this.executor.decodeWindowK;
+				if (windowK > 0) {
+					let produced = 0;
+					let stopped = false;
+					while (!stopped && produced < stepsNeeded) {
+						const steps = Math.min(windowK, stepsNeeded - produced);
+						this.executor.submitGreedyDecodeWindow(produced === 0 ? firstToken : null, steps, 0);
+						const tokens = await this.executor.readDecodeWindow(0, steps);
+						produced += steps;
+						for (const tok of tokens) if (consumeToken(tok)) {
+							stopped = true;
+							break;
+						}
+					}
+				} else {
+					const depth = Executor.PIPELINE_DEPTH;
+					let submitted = 0;
+					let consumed = 0;
+					while (consumed < stepsNeeded) {
+						while (submitted < stepsNeeded && submitted < consumed + depth) {
+							this.executor.submitGreedyDecodeStep(submitted === 0 ? firstToken : null, submitted % depth);
+							submitted++;
+						}
+						const tok = await this.executor.readDecodeToken(consumed % depth);
+						consumed++;
+						if (consumeToken(tok)) break;
 					}
-					const tok = await this.executor.readDecodeToken(consumed % depth);
-					consumed++;
-					if (consumeToken(tok)) break;
 				}
 			}
 		} else {
@@ -5705,7 +6383,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond,
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/**
@@ -6214,7 +6893,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond: tokensGenerated / (totalTime / 1e3),
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/** Prepare + prefill + decode for a fully-specified multimodal token sequence. */
@@ -6299,7 +6979,8 @@ var WebGPUEngine = class WebGPUEngine {
 			tokensGenerated,
 			tokensPerSecond: tokensGenerated / (totalTime / 1e3),
 			totalTime,
-			finishReason
+			finishReason,
+			tokenIds: [...generatedIds]
 		};
 	}
 	/**
@@ -6780,5 +7461,5 @@ var WebGPUEngine = class WebGPUEngine {
 };
 
 //#endregion
-export { dequantizeGemma4VisionProjection as A, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, generateGemma4VisionGraph as M, patchGemma4VisionClips as N, KaniTTS as O, resolveGemma4VisionInfo as P, loadOuteSpeaker as S, generateDacSpeechDecoderGraph as T, smartResize as _, buildGemma4PosEmbeds as a, OuteTTS as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, dequantizeMLXProjection as j, generateQwen3_5VisionGraph as k, buildMRoPEPositionIds as l, mropeFreqDims as m, GEMMA4_IMAGE_PROCESSOR as n, buildGemma4RotaryCosSin as o, buildVisionPositionTensors as p, QWEN3_5_IMAGE_PROCESSOR as r, buildGemma4VisionPositionTensors as s, WebGPUEngine as t, buildPosEmbeds as u, VisionExecutor as v, dacOutputLength as w, buildOutePromptString as x, ParlerTTS as y };
-//# sourceMappingURL=gpu-CrzjQHv2.mjs.map
+export { KaniTTS as A, audioTokensToDacCodes as C, parseOuteTtsConfig as D, generateOuteTtsBackboneGraph as E, patchGemma4VisionClips as F, resolveGemma4VisionInfo as I, dequantizeGemma4VisionProjection as M, dequantizeMLXProjection as N, Swarm as O, generateGemma4VisionGraph as P, loadOuteSpeaker as S, generateDacSpeechDecoderGraph as T, smartResize as _, buildGemma4PosEmbeds as a, OuteTTS as b, buildMRoPECosSin as c, buildPositionIds as d, buildRotaryCosSin as f, preprocessImageGemma4 as g, preprocessImage as h, buildGemma4PoolMatrix as i, generateQwen3_5VisionGraph as j, RequestScheduler as k, buildMRoPEPositionIds as l, mropeFreqDims as m, GEMMA4_IMAGE_PROCESSOR as n, buildGemma4RotaryCosSin as o, buildVisionPositionTensors as p, QWEN3_5_IMAGE_PROCESSOR as r, buildGemma4VisionPositionTensors as s, WebGPUEngine as t, buildPosEmbeds as u, VisionExecutor as v, dacOutputLength as w, buildOutePromptString as x, ParlerTTS as y };
+//# sourceMappingURL=gpu-DRFhiv4R.mjs.map