@tryhamster/gerbil 1.11.3 → 1.12.0

package/dist/{index-DeKYzJgJ.d.mts → index-CNYoTRgr.d.mts}

@@ -814,524 +814,6 @@ declare function quantizeKaniBackbone(graph: ModelGraph, weights: Map<string, {
   shape: number[];
 }>): void;
 //#endregion
-//#region src/gpu/sampler.d.ts
-/**
- * CPU-side token sampling from logits.
- *
- * Applies temperature, top-k, and top-p (nucleus) filtering,
- * then samples from the resulting probability distribution.
- *
- * Uses typed arrays and min-heap for zero-allocation top-K selection.
- * For vocab_size ~152K with topK=50, this avoids creating 152K JS tuples.
- */
-interface SamplingParams {
-  temperature?: number;
-  topK?: number;
-  topP?: number;
-  repetitionPenalty?: number;
-}
-//#endregion
-//#region src/gpu/vision-preprocess.d.ts
-/**
- * Host-side vision preprocessing for the Qwen3.5 ViT.
- *
- * The learned position embeddings (bilinear-interpolated over the patch grid)
- * and the 2D rotary cos/sin tables are functions of the image grid (t, h, w)
- * ONLY — not of the model weights or pixel values. They are cheap to compute on
- * the CPU and fed to the GPU graph as input activations, keeping the graph to
- * weight-dependent math while staying byte-identical to HF transformers.
- *
- * Ports (verified against transformers 5.12 vision_utils.py + modeling_qwen3_5):
- *   - get_vision_bilinear_indices_and_weights  → buildPosEmbeds()
- *   - get_vision_position_ids                  → buildPositionIds()
- *   - Qwen3_5VisionRotaryEmbedding             → buildRotaryCosSin()
- *
- * Patch ordering: both the pos-embed gather and the position ids reorder patches
- * into spatial_merge_size×spatial_merge_size groups, matching the HF image
- * processor's output ordering, so the merger's [N,h]→[N/u,h*u] reshape lines up.
- */
-interface VisionGridConfig {
-  hiddenSize: number;
-  numHeads: number;
-  numPositionEmbeddings: number;
-  spatialMergeSize: number;
-  ropeTheta?: number;
-}
-interface VisionPositionTensors {
-  /** [N, hidden_size] bilinear-interpolated learned position embeddings. */
-  posEmbeds: Float32Array;
-  /** [N, head_dim] rotary cosines. */
-  cos: Float32Array;
-  /** [N, head_dim] rotary sines. */
-  sin: Float32Array;
-  numPatches: number;
-}
-/**
- * Build bilinear-interpolated learned position embeddings [N, hidden].
- * posEmbedTable is the raw pos_embed.weight [num_position_embeddings, hidden].
- */
-declare function buildPosEmbeds(gridTHW: [number, number, number], posEmbedTable: Float32Array, cfg: VisionGridConfig): Float32Array;
-/**
- * Build the reordered (row, col) position ids [N, 2] for rotary, matching
- * get_vision_position_ids.
- */
-declare function buildPositionIds(gridTHW: [number, number, number], merge: number): Int32Array;
-/**
- * Build rotary cos/sin tables [N, head_dim] from position ids, matching
- * Qwen3_5VisionRotaryEmbedding + the cat((rotary, rotary)) in VisionModel.forward.
- *
- * rotary_pos_emb(position_ids) = (position_ids[..,None] * inv_freq).flatten(1)
- *   where inv_freq has length (head_dim/2)/2 = head_dim/4, computed over dim=head_dim/2.
- * For each token the two position components (h, w) each produce head_dim/4 freqs,
- * concatenated → head_dim/2, then duplicated → head_dim for cos/sin.
- */
-declare function buildRotaryCosSin(positionIds: Int32Array, headDim: number, theta?: number): {
-  cos: Float32Array;
-  sin: Float32Array;
-  numPatches: number;
-};
-/**
- * Build all host position tensors for a single image grid in one call.
- */
-declare function buildVisionPositionTensors(gridTHW: [number, number, number], posEmbedTable: Float32Array, cfg: VisionGridConfig): VisionPositionTensors;
-interface Gemma4VisionGridConfig {
-  hiddenSize: number;
-  numHeads: number;
-  headDim: number;
-  ropeTheta: number;
-  poolingKernelSize: number;
-}
-interface Gemma4VisionPositionTensors {
-  /** [N, hidden] axial position embeddings (table[0][x] + table[1][y]). */
-  posEmbeds: Float32Array;
-  /** [N, headDim] axial rotary cosines. */
-  cos: Float32Array;
-  /** [N, headDim] axial rotary sines. */
-  sin: Float32Array;
-  /** [Np, N] average-pooling matrix (1/k² in-cell, 0 elsewhere). */
-  poolMatrix: Float32Array;
-  /** number of patches N (= gridH*gridW). */
-  numPatches: number;
-  /** number of pooled (soft) tokens Np (= ceil(gridH/k)*ceil(gridW/k)). */
-  numPooled: number;
-}
-/**
- * Build axial learned position embeddings [N, hidden] from the [2, posSize, hidden]
- * table: pos[p] = table[0][x_p] + table[1][y_p]. Direct lookup, no interpolation
- * (HF F.embedding on clamped positions).
- */
-declare function buildGemma4PosEmbeds(gridH: number, gridW: number, posEmbedTable: Float32Array,
-// [2, posSize, hidden] flattened
-hidden: number, posSize: number): Float32Array;
-/**
- * Build the 2D axial rotary cos/sin tables [N, headDim].
- *   spatial_dim = headDim / 2;  inv_freq[j] = 1/theta^((2j)/spatial_dim), j in [0, spatial_dim/2)
- *   per spatial dim: f = pos * inv_freq (spatial_dim/2 values); emb = cat(f, f) (spatial_dim values)
- *   cos/sin = cat([emb_x, emb_y]) → headDim values, layout [fx,fx,fy,fy].
- * Applied with the global-half rotate_half kernel (ApplyRotaryEmb), which computes
- * out = x*cos + rotate_half(x)*sin element-wise — exact for this layout.
- */
-declare function buildGemma4RotaryCosSin(gridH: number, gridW: number, headDim: number, theta: number): {
-  cos: Float32Array;
-  sin: Float32Array;
-};
-/**
- * Build the [Np, N] average-pooling matrix for k×k spatial pooling over the real
- * (unpadded) grid, matching modeling_gemma4's kernel_idxs/one_hot pooling:
- *   cell(p) = floor(x_p/k) + ceil(gridW/k) * floor(y_p/k)
- *   poolMatrix[cell, p] = 1/k²  (so pooled = poolMatrix @ hidden = mean over the k×k block)
- * Np = ceil(gridH/k) * ceil(gridW/k). Each pooled cell averages exactly the patches
- * that fall in it (edge cells with fewer than k² patches still divide by k², matching
- * HF's fixed 1/k² normalization).
- */
-declare function buildGemma4PoolMatrix(gridH: number, gridW: number, k: number): {
-  poolMatrix: Float32Array;
-  numPooled: number;
-};
-/**
- * Build all Gemma 4 vision host tensors for one image grid in one call.
- * `posEmbedTable` is the raw [2, posSize, hidden] flattened table.
- */
-declare function buildGemma4VisionPositionTensors(gridH: number, gridW: number, posEmbedTable: Float32Array, posSize: number, cfg: Gemma4VisionGridConfig): Gemma4VisionPositionTensors;
-/** Gemma 4 image processor config (from processor_config.json). */
-declare const GEMMA4_IMAGE_PROCESSOR: ImageProcessorConfig;
-interface Gemma4PreprocessedImage {
-  /** Flattened patches [N, 3·patch²] row-major (row-major patch grid). */
-  patches: Float32Array;
-  /** Patch grid (gridH, gridW). */
-  gridHW: [number, number];
-}
-/**
- * Preprocess a decoded RGB image for the Gemma 4 ViT: aspect-preserving resize so
- * the patch grid is ≤ max_soft_tokens·k² patches and H,W divisible by k·patch,
- * rescale ×1/255 (no normalize), patchify row-major into [N, 3·16·16].
- *
- * @param pixels row-major HWC RGB (0..255), length width*height*3.
- */
-declare function preprocessImageGemma4(pixels: Float32Array | Uint8ClampedArray | Uint8Array, width: number, height: number, maxSoftTokens?: number, poolingKernelSize?: number, patchSize?: number): Gemma4PreprocessedImage;
-interface ImageProcessorConfig {
-  patchSize: number;
-  temporalPatchSize: number;
-  mergeSize: number;
-  imageMean: [number, number, number];
-  imageStd: [number, number, number];
-  /** rescale factor applied to raw 0..255 pixels before normalization (1/255). */
-  rescaleFactor: number;
-  /** min total pixels after resize (shortest_edge). */
-  minPixels: number;
-  /** max total pixels after resize (longest_edge). */
-  maxPixels: number;
-}
-declare const QWEN3_5_IMAGE_PROCESSOR: ImageProcessorConfig;
-interface PreprocessedImage {
-  /** Flattened patches [N, 1536] in the spatial-merge order encodeImage expects. */
-  patches: Float32Array;
-  /** (t, h, w) patch grid. t=1 for a single image, h/w in patch units. */
-  gridTHW: [number, number, number];
-}
-/**
- * Qwen2-VL smart-resize: round H and W to multiples of factor=patch*merge,
- * keeping aspect ratio and clamping the total pixel budget to [minPixels, maxPixels].
- * Matches transformers.models.qwen2_vl.image_processing.smart_resize.
- */
-declare function smartResize(height: number, width: number, factor: number, minPixels: number, maxPixels: number): [number, number];
-/**
- * Preprocess a decoded RGB image into the [N, 1536] patch tensor + grid_thw that
- * `encodeImage()` expects, matching the HF Qwen2-VL image processor:
- *   smart_resize → rescale (×1/255) → normalize → temporal-pair (×temporal_patch_size)
- *   → patchify into spatial_merge×spatial_merge blocks → flatten to [N, C·T·P·P].
- *
- * @param pixels row-major HWC RGB, length width*height*3. Values 0..255 (default)
- *   or already 0..1 if `rescaled` is true.
- * @param width  source pixel width
- * @param height source pixel height
- */
-declare function preprocessImage(pixels: Float32Array | Uint8ClampedArray | Uint8Array, width: number, height: number, cfg?: ImageProcessorConfig, rescaled?: boolean): PreprocessedImage;
-declare function buildMRoPEPositionIds(inputIds: Int32Array | Uint32Array | number[], imageGrids: Array<[number, number, number]>, imageTokenId: number, mergeSize: number): Int32Array;
-/**
- * Per-pair frequency→dimension assignment for interleaved M-RoPE, matching
- * Qwen3_5TextRotaryEmbedding.apply_interleaved_mrope. For pair index i in
- * [0, sum(section)) the position component is section-cyclic: T,H,W,T,H,W,...
- * but each component capped at its section count. Returns an array of length
- * (rope_dim/2) with values 0=T, 1=H, 2=W.
- */
-declare function mropeFreqDims(mropeSection: [number, number, number]): Int32Array;
-/**
- * Build the interleaved-M-RoPE cos/sin tables [seq, rope_dim] from 3D position
- * ids, matching Qwen3_5TextRotaryEmbedding.forward:
- *   freqs[d][i] = pos[d] * inv_freq[i],  inv_freq[i] = 1/theta^(2i/rope_dim)
- *   freq[i] picks component mropeFreqDims[i]; emb = cat(freqs, freqs).
- * cos/sin have length seq*rope_dim. For text-only (all 3 pos rows equal) this
- * reduces exactly to standard 1D partial RoPE.
- *
- * @param positionIds3 [3, seq] as produced by buildMRoPEPositionIds.
- * @param ropeDim      number of rotated dims per head (head_dim * partial_factor).
- */
-declare function buildMRoPECosSin(positionIds3: Int32Array, seq: number, ropeDim: number, theta: number, mropeSection: [number, number, number]): {
-  cos: Float32Array;
-  sin: Float32Array;
-};
-//#endregion
-//#region src/gpu/defaults.d.ts
-/**
- * Default model per capability. Kept in its own tiny module (no heavy imports)
- * so the React hooks can resolve defaults without statically pulling in the GPU
- * engine — they import the engine dynamically to stay light.
- */
-declare const DEFAULT_MODELS: {
-  /** Text generation (also the vision-capable checkpoint). */
-  readonly text: "mlx-community/Qwen3.5-0.8B-4bit";
-  /** Image understanding — same checkpoint, vision tower built on demand. */
-  readonly vision: "mlx-community/Qwen3.5-0.8B-4bit";
-  /** Text embeddings. */
-  readonly embedding: "mlx-community/embeddinggemma-300m-4bit";
-  /** Text-to-speech (Apache-2.0; LFM2-350M backbone + NanoCodec). Small/fast default. */
-  readonly tts: "nineninesix/kani-tts-450m-0.2-ft";
-  /**
-   * Selectable many-voices TTS (OuteTTS-1.0-0.6B: Qwen3-0.6B codec-LM + DAC.speech).
-   * Pass this as the `repo`/`model` to engine.speak()/useTTS to route to OuteTTS.
-   */
-  readonly ttsOute: "OuteAI/OuteTTS-1.0-0.6B";
-  /**
-   * Selectable describe-your-voice TTS (Parler-TTS-mini-v1: Flan-T5 encoder +
-   * cross-attending decoder LM + dac_44khz). Pass this as the `repo`/`model` to
-   * engine.speak()/useTTS with a `describeVoice` natural-language description.
-   */
-  readonly ttsParler: "parler-tts/parler-tts-mini-v1";
-  /** Speech-to-text. */
-  readonly stt: "UsefulSensors/moonshine-base";
-};
-declare const OUTETTS_ASSETS: {
-  /** Folded DAC.speech.v1.0 encoder+decoder weights (prep-dac-speech.py output). */
-  readonly codecWeightsURL: "https://pub-0522ecec25fc412bb35a523f3e3f63c6.r2.dev/tryhamster/gerbil-outetts-assets/dac-speech-folded.safetensors";
-  /** Base URL for the preset speaker JSONs (`{name}.json`). */
-  readonly speakersBaseURL: "https://pub-0522ecec25fc412bb35a523f3e3f63c6.r2.dev/tryhamster/gerbil-outetts-assets/speakers";
-  /** The default preset voice. */
-  readonly defaultVoice: "en-female-1-neutral";
-};
-/**
- * Bundled OuteTTS preset voices.
- *
- * Provenance (honest labelling):
- *  - `en-female-1-neutral` is the ONE AUTHENTIC OuteAI voice — the OuteTTS v3 bundled
- *    default speaker (default_speakers/en-female-1-neutral), copied verbatim.
- *  - `gerbil-voice-2..6` are DERIVED voices: distinct timbres produced by running
- *    pitch/tempo-varied renderings of that authentic clip back through the REAL
- *    DAC.speech encode + prosody pipeline (scripts/engine/stage-outetts-assets.py).
- *    They are genuine DAC-encoded OuteSpeakers, but they are NOT OuteAI's own
- *    `en-male-*` voices, so they are not labelled as such. (Earlier builds mislabelled
- *    them as `en-male-2-neutral` etc.; renamed for honesty.)
- */
-declare const OUTETTS_PRESET_VOICES: readonly ["en-female-1-neutral", "gerbil-voice-2", "gerbil-voice-3", "gerbil-voice-4", "gerbil-voice-5", "gerbil-voice-6"];
-/**
- * True when `repo`/`architecture` identify a text-to-speech checkpoint that must
- * run through a dedicated native TTS engine (KaniTTS, OuteTTS, or Parler-TTS)
- * rather than the single-graph base text loader. Mirrors the routing used by
- * `WebGPUEngine.speak()` / `Gerbil.ensureNativeTTSEngine`:
- *   - Parler  → encoder-decoder (`ParlerTTSForConditionalGeneration`)
- *   - OuteTTS → Qwen3-0.6B codec-LM
- *   - Kani    → conv-backbone codec-LM (`KaniTTS2ForCausalLM`, or the Apache
- *               default which is a plain `Lfm2ForCausalLM` — hence the repo-name
- *               gate; the architecture string alone does not identify it).
- * At `create()` time only the repo is known (the architecture is discovered
- * during load), so the repo-name signals below cover all three DEFAULT_MODELS
- * and conventionally-named TTS repos; the architecture arg is honored when a
- * caller already has it.
- */
-declare function isTTSRepo(repo?: string, architecture?: string): boolean;
-/** Resolve the model repo for a set of options, falling back to the defaults. */
-declare function resolveDefaultRepo(opts: {
-  repo?: string;
-  embedding?: boolean;
-  enableVision?: boolean;
-}): string;
-//#endregion
-//#region src/gpu/architectures/gemma4_vision.d.ts
-interface Gemma4VisionGraphInfo {
-  hiddenSize: number;
-  numHeads: number;
-  headDim: number;
-  depth: number;
-  intermediateSize: number;
-  textHidden: number;
-  patchSize: number;
-  patchDim: number;
-  poolingKernelSize: number;
-  ropeTheta: number;
-  rmsNormEps: number;
-}
-/**
- * Resolve the Gemma 4 vision dims from a raw HF config. Accepts either the
- * top-level config (reads `.vision_config` + `.text_config.hidden_size`) or a
- * bare vision_config (then `textHidden` falls back to the projector row count if
- * present, else hidden). Family-general — no E2B constants.
- */
-declare function resolveGemma4VisionInfo(rawConfig: Record<string, unknown>): Gemma4VisionGraphInfo;
-/**
- * Dequantize an MLX affine-int4 weight to a plain f32 [rows, cols] matrix.
- * MLX packs 8 int4 values per u32 (low-nibble first); each group of `groupSize`
- * columns shares one scale + bias: w[r,c] = scale[r, c/gs] * q + bias[r, c/gs].
- * Used for the Gemma 4 multimodal projector (`embed_vision.embedding_projection`)
- * in MLX-4bit checkpoints, where (unlike the BF16 ViT body) the projector is int4.
- */
-declare function dequantizeMLXProjection(packed: Uint32Array, scales: Float32Array, biases: Float32Array, rows: number, cols: number, groupSize: number): Float32Array;
-/**
- * If the Gemma 4 multimodal projector arrived as an MLX affine-int4 triplet
- * (`embed_vision.embedding_projection.{weight(U32), scales, biases}`), dequantize
- * it in-place to a plain f32 `embed_vision.embedding_projection.weight` and drop
- * the scales/biases, so the vision graph's plain MatMul on the projector works for
- * MLX-4bit checkpoints too. No-op for BF16 (HF) checkpoints (weight already f32).
- */
-declare function dequantizeGemma4VisionProjection(weights: Map<string, {
-  data: ArrayBufferView;
-  shape: number[];
-}>, groupSize: number, rows: number, cols: number): void;
-/**
- * Patch the ClippedMatMul nodes of a Gemma 4 vision graph with the calibrated clip
- * scalars from the checkpoint (Gemma4ClippableLinear's per-tensor input/output
- * min/max buffers), then drop those scalar tensors from the weights map so the
- * vision executor doesn't try to upload them as GPU buffers. Call BEFORE
- * VisionExecutor.uploadWeights(). Missing scalars default to ±inf (clip = identity),
- * so a checkpoint without calibration still loads.
- */
-declare function patchGemma4VisionClips(graph: ModelGraph, weights: Map<string, {
-  data: ArrayBufferView;
-  shape: number[];
-}>): void;
-/**
- * Build the Gemma 4 ViT graph. Shaped by symbolic "N" (number of patches, runtime)
- * and "Np" (number of pooled tokens = ceil(grid_h/k)·ceil(grid_w/k), runtime),
- * resolved from input tensor dims — like the Qwen ViT's "N"/"Nm".
- */
-declare function generateGemma4VisionGraph(rawConfig: Record<string, unknown>): ModelGraph;
-//#endregion
-//#region src/gpu/architectures/kani_tts.d.ts
-/** Parsed KaniTTS2 backbone config (the LFM2 dims + the TTS-specific fields). */
-interface KaniConfig {
-  textVocabSize: number;
-  vocabSize: number;
-  tokensPerFrame: number;
-  audioStep: number;
-  useLearnableRope: boolean;
-  alphaMin: number;
-  alphaMax: number;
-  speakerEmbDim: number;
-  audioTokensStart: number;
-  startOfSpeech: number;
-  endOfSpeech: number;
-  codebookSize: number;
-  /**
-   * Whether the backbone uses KaniTTS2's frame-level position IDs (the 4 audio
-   * tokens of a frame share one logical position) + learnable per-layer RoPE.
-   * The `KaniTTS2ForCausalLM` checkpoints (e.g. kani-tts-2-en) do; the plain
-   * `Lfm2ForCausalLM` family (e.g. the Apache kani-tts-450m-0.2-ft / kani-tts-370m)
-   * does NOT — those run standard sequential positions with α=1 plain RoPE.
-   * Detected from the presence of `use_learnable_rope`/`tokens_per_frame`/the
-   * `KaniTTS2ForCausalLM` architecture marker in config.json.
-   */
-  frameLevelPositions: boolean;
-}
-declare function parseKaniConfig(rawConfig: Record<string, unknown>): KaniConfig;
-/**
- * Convert the model's flat audio-token stream (the IDs between start/end-of-speech)
- * into NanoCodec codes [NUM_GROUPS, T]. Mirrors NemoAudioPlayer.get_nano_codes:
- *   reshape [-1, 4]; codes[:,c] -= codebook_size*c; codes -= audio_tokens_start;
- *   transpose → [4, T]. Returns a Uint32Array laid out group-major ([g*T + t]).
- */
-declare function audioTokensToCodes(audioTokenIds: number[], cfg?: KaniConfig): {
-  codes: Uint32Array;
-  numFrames: number;
-};
-interface NanoCodecGraphOptions {
-  /** Number of audio frames T (the code grid width). PCM length = T * 1764. */
-  numFrames: number;
-}
-declare function generateNanoCodecDecoderGraph(opts: NanoCodecGraphOptions): ModelGraph;
-/**
- * Generate the KaniTTS codec-LM backbone graph (LFM2-350M body, full-vocab logits,
- * per-layer learnable MRoPE). Mirrors generateLfm2Graph block-for-block; the only
- * difference is that each attention layer rotates Q/K with the MRoPE op fed a
- * per-layer host cos/sin table instead of the position-counter RoPE op.
- *
- * dtype:
- *   • undefined / "f32" — full precision (the checkpoint is bf16/f32 → f32).
- *   • "q4" — weight-only group-wise INT4 (W4A16) for the LFM2 linear projections
- *     (q/k/v/o, gate/up/down, short-conv in/out_proj) via MatMulInt4. The tied
- *     embedding + LM head stay at f32 on purpose: decoder-LM heads are the most
- *     quantization-sensitive part of a codec-LM and the embed table is the single
- *     buffer shared by both, so quantizing it would degrade audio quality for no
- *     load-size win that the int4 projections do not already capture. Backbone
- *     drops from ~1.5 GB (f32) to ~0.37 GB. The NanoCodec decoder is a separate
- *     graph and always runs f32.
- */
-declare function generateKaniTtsGraph(rawConfig: Record<string, unknown>, dtype?: GraphDType, groupSize?: number, kvDtype?: KVDType): ModelGraph;
-//#endregion
-//#region src/gpu/architectures/moonshine.d.ts
-/**
- * Historical record of the executor-side work the keystone left open; all items
- * are now implemented (see the STATUS note above). Retained as exported
- * documentation of the dependency surface.
- */
-declare const MOONSHINE_REMAINING_WORK: readonly ["DONE: Transpose op kernel (conv output [C,L] → encoder input [L,C]).", "DONE: GroupNorm(num_groups=1) over conv channels (weight+bias).", "DONE: Tanh elementwise op (conv1 activation).", "DONE: Interleaved-RoPE variant (Moonshine rotates adjacent dim pairs 2p/2p+1).", "DONE: No-bias LayerNorm variant (Moonshine norms are weight-only).", "DONE: Per-utterance conv graph regeneration from the concrete sample count.", "DONE: Dual-graph executor — encoder once → frozen cross-attn K/V → AR decode.", "DONE: engine.transcribe(pcm) host path (MoonshineSTT): conv → encode → AR decode → detokenize."];
-interface MoonshineDims {
-  hidden_size: number;
-  enc_layers: number;
-  dec_layers: number;
-  num_heads: number;
-  num_kv_heads: number;
-  head_dim: number;
-  rotary_dim: number;
-  intermediate_size: number;
-  vocab_size: number;
-  rope_base: number;
-  context_length: number;
-  ln_eps: number;
-}
-/** Pull and derive Moonshine dimensions from the raw HF config. */
-declare function parseMoonshineConfig(raw: Record<string, unknown>): MoonshineDims;
-/** Number of encoder frames produced by the conv frontend for n_samples PCM. */
-declare function moonshineEncoderFrames(nSamples: number): number;
-/**
- * Encoder graph: raw-waveform conv frontend + bidirectional transformer.
- * @param nSamples concrete PCM sample count (the conv frontend is length-static).
- * The output tensor "encoder_out" is [T_frames, hidden] and is consumed (after
- * per-layer K/V projection) as the frozen K/V for the decoder's cross-attention.
- */
-declare function generateMoonshineEncoderGraph(raw: Record<string, unknown>, nSamples: number): ModelGraph;
-/**
- * Decoder graph: AR transformer with causal self-attn (KV-cache) + cross-attn to
- * the frozen encoder output. Built for a single decode step (T=1). The encoder K/V
- * are supplied as graph inputs "enc_k_layer{i}" / "enc_v_layer{i}" — the host
- * pre-projects the encoder output through each layer's encoder_attn.k_proj/v_proj
- * ONCE and binds them frozen for the whole decode (the CrossAttention contract).
- */
-declare function generateMoonshineDecoderGraph(raw: Record<string, unknown>, sEnc: number): ModelGraph;
-//#endregion
-//#region src/gpu/architectures/outetts.d.ts
-/** Parsed OuteTTS backbone config (the Qwen3 dims). Reuses the generic Qwen path. */
-interface OuteTtsConfig {
-  hidden_size: number;
-  num_layers: number;
-  num_heads: number;
-  num_kv_heads: number;
-  head_dim: number;
-  intermediate_size: number;
-  vocab_size: number;
-  rope_base: number;
-  rms_norm_eps: number;
-  max_position_embeddings: number;
-}
-declare function parseOuteTtsConfig(rawConfig: Record<string, unknown>): OuteTtsConfig;
-/**
- * Convert the flat generated token stream (the run BETWEEN <|audio_start|> and
- * <|audio_end|>) into a DAC code grid [NUM_CODEBOOKS, T] (codebook-major [c*T + t]).
- *
- * Mirrors outetts v3 `extract_audio_from_tokens`: filter the stream into two ordered
- * lists by membership of the c1 / c2 ranges, recover the raw code
- * (id − base), drop the reserved index 1024, and truncate to the shorter list. The
- * model emits c1,c2 interleaved per frame, but the parse is membership-based (it does
- * not assume strict pairing) so a stray token cannot desync the grid.
- */
-declare function audioTokensToDacCodes(tokenIds: number[]): {
-  codes: Uint32Array;
-  numFrames: number;
-};
-interface DacSpeechGraphOptions {
-  /** Number of audio frames T (the code-grid width). */
-  numFrames: number;
-  /**
-   * Number of RVQ codebooks. Default 2 (DAC.speech.v1.0). Parler-TTS's
-   * dac_44khz_8kbps uses 9 — the RVQDequant kernel loops over NCB so the only
-   * change is the codebook/out_proj tensor first-dim and the codes grid height.
-   */
-  numCodebooks?: number;
-  /**
-   * Decoder upsampling rates (the DecoderBlock strides). Default [8,5,4,2]
-   * (DAC.speech.v1.0). Parler's dac_44khz uses [8,8,4,2] (hop 512). Channels
-   * still halve per stage from `decoderDim`.
-   */
-  decoderRates?: readonly number[];
-  /** First-conv output channels (decoder_dim). Default 1536. */
-  decoderDim?: number;
-  /** Quantizer out_proj output / first-conv input dim (latent_dim). Default 1024. */
-  latentDim?: number;
-}
-declare function generateDacSpeechDecoderGraph(opts: DacSpeechGraphOptions): ModelGraph;
-/**
- * Final decoded PCM length (samples) for a T-frame code grid, via the DAC stage chain.
- * `rates` defaults to DAC.speech.v1.0 ([8,5,4,2]); pass [8,8,4,2] for Parler's dac_44khz.
- */
-declare function dacOutputLength(numFrames: number, rates?: readonly number[]): number;
-declare function generateOuteTtsBackboneGraph(rawConfig: Record<string, unknown>, dtype?: GraphDType, groupSize?: number, kvDtype?: KVDType): ModelGraph;
-//#endregion
-//#region src/gpu/architectures/qwen3_5_vision.d.ts
-/**
- * Build the ViT graph. The graph is shaped by symbolic "N" (number of patches),
- * resolved at run time from the input tensor's first dim — exactly like the LM's
- * symbolic "T".
- */
-declare function generateQwen3_5VisionGraph(rawConfig: Record<string, unknown>): ModelGraph;
-//#endregion
 //#region src/gpu/executor.d.ts
 /**
  * Safari/Metal workaround: shader variant alternation.
@@ -1399,6 +881,17 @@ declare class Executor {
   private argmaxReadback;
   /** Readback ring for pipelined greedy decode (created lazily). */
   private decodeReadbacks;
+  /** Window size K (GERBIL_DECODE_WINDOW). 0 = off. */
+  readonly decodeWindowK: number;
+  /** Readback ring for decode windows (4·K bytes per slot; created lazily). */
+  private windowReadbacks;
+  /**
+   * Per-step uniform/bind-group variants for the few seq-pos-dependent decode
+   * entries (RoPE position, KV-append offset, attention S). Keyed by nodeId;
+   * index k holds the variant used at window step k (1..K-1 — step 0 uses the
+   * entry's base uniform). Created lazily, rewritten per window pre-submit.
+   */
+  private windowVariants;
   /**
    * Staging buffer for uniform param updates.
    * Safari/Metal has weaker visibility guarantees for queue.writeBuffer() to
@@ -1431,6 +924,48 @@ declare class Executor {
   private kvMode;
   private seqPos;
   private webkitGroupSize;
+  private readonly pagedKV;
+  private kvBlockManager;
+  /** Lockstep batch width (GERBIL_BATCH). 0 = batching off. */
+  readonly batchSize: number;
+  /** Block-table row stride — set for any paged mode. */
+  private maxBlocksPerSeq;
+  /** Block-table row the single-sequence paths target (batch prefill slot). */
+  private activeSeqSlot;
+  /** Batched dispatch entries (built once in initBindGroups when batch on). */
+  private batchEntries;
+  /** Per-slot SSM/conv state pools: slot b's state at offset b*slotBytes. */
+  private batchSsmPools;
+  /** Batch-widened tail buffers (SliceLastRow output + logits at [N, ...]). */
+  private batchTailBuffers;
+  private batchPositionsBuffer;
+  private batchSeqLensBuffer;
+  private batchSampledBuffer;
+  private batchReadbacks;
+  private batchArgmaxEntry;
+  /** JS-side authoritative per-slot token counts (positions source). */
+  private batchSeqLens;
+  /** Scratch for per-step positions/seq_lens uploads. */
+  private batchPositionsScratch;
+  private batchSeqLensScratch;
+  /** Cached batch-resolved shapes (static: T == batchSize every step). */
+  private batchShapes;
+  /** True once the batched-argmax uniform has been written this session. */
+  private batchArgmaxParamsWritten;
+  /** True when GERBIL_BATCH_LORA=1 rode in on an active batch path. */
+  readonly batchLoraEnabled: boolean;
+  /** Registered adapters (expanded deltas), indexed by adapter id. */
+  private batchAdapterDeltas;
+  /** Per-lane adapter ids (u32; 0xFFFFFFFF = bare base). */
+  private batchAdapterIdsBuffer;
+  /** GPU buffers owned by the batch-LoRA overlay (factors, maps, tmp, uniforms). */
+  private batchLoraBuffers;
+  /** Batch entries snapshotted BEFORE the batch fusion passes (overlay base). */
+  private batchEntriesUnfused;
+  /** Batch entries with the per-lane LoRA dispatches spliced in. */
+  private batchEntriesLoRA;
+  /** True while at least one lane carries an adapter (set by setBatchLaneAdapters). */
+  private batchLoraActive;
   private profileEnabled;
   private readonly profileData;
   private querySet;
@@ -1573,8 +1108,15 @@ declare class Executor {
   private buildSelectiveLoraDecode;
   /**
    * Run a forward pass. Uses matvec kernels for M=1 (decode), tiled for M>1 (prefill).
+   *
+   * `opts.readLogits: false` skips the logits copy + readback entirely (the
+   * returned logits array is empty) and returns right after submission — used
+   * by the scheduler's chunked prefill, where only the FINAL chunk's logits
+   * are ever sampled. seqPos still advances by T.
    */
-  forward(inputIds: Uint32Array): Promise<ForwardResult>;
+  forward(inputIds: Uint32Array, opts?: {
+    readLogits?: boolean;
+  }): Promise<ForwardResult>;
   /**
    * Profiling variant of the desktop dispatch path: one compute pass per dispatch,
    * each bracketed by timestamp queries, so we get per-op GPU time. Accumulates
@@ -1605,6 +1147,14 @@ declare class Executor {
    * tiny dispatch) is intentionally excluded — it is not a hotspot target.
    */
   profileDecodeStep(tokenId: number): Promise<void>;
+  /**
+   * Profile ONE batched decode step (GERBIL_BATCH): times each batchEntries
+   * dispatch with timestamp queries, accumulating GPU ns per opType into the
+   * same profile as profileDecodeStep. Measurement-only (un-pipelined, CPU
+   * tokens). Call after prefilling the batch slots; advances every slot by
+   * one position like a real step.
+   */
+  profileBatchDecodeStep(tokens: Uint32Array<ArrayBuffer>): Promise<void>;
   /**
    * Run a single forward pass over `inputIds` and read back the L2-normalized
    * embedding vector. Requires an embedding graph (one whose output tensor is
@@ -1663,6 +1213,44 @@ declare class Executor {
   submitGreedyDecodeStep(tokenId: number | null, slot: number): void;
   /** Read back the token produced by the pipelined step that used `slot`. */
   readDecodeToken(slot: number): Promise<number>;
+  /**
+   * K-step greedy decode window (GERBIL_DECODE_WINDOW=K — dispatch-collapse
+   * campaign Lever 1; Dawn only).
+   *
+   * Records `steps` full decode forwards + argmax into ONE command buffer and
+   * submits once. Between recorded steps the previous step's argmax result is
+   * copied into input_ids ON THE GPU (the same 4-byte chain the pipelined path
+   * uses across submits), so no CPU sync exists inside the window. Each step's
+   * winning token id is copied into the slot's window readback at offset 4·k;
+   * {@link readDecodeWindow} maps it once per window.
+   *
+   * Seq-pos-dependent entries (RoPE position, KV-append offset, attention S —
+   * ~3 per full-attention layer; Mamba layers carry state and have none) get
+   * lazily-built per-step uniform/bind-group variants, ALL written with
+   * queue.writeBuffer BEFORE the submit (queue-ordered, so safe with a prior
+   * window still in flight). Params are built against per-step resolved shapes
+   * (L_max tensors resolve to seqPos+T — attention S comes from the KV shape).
+   * Dispatch grids are encoded ONCE per window at the worst case (last step's
+   * shapes, pos+K-1): decode grids are step-invariant in practice, and any
+   * L_max-derived grid over-dispatches for early steps, which is safe because
+   * kernels bound their work from uniforms.
+   *
+   * EOS is only observable at window granularity: up to K-1 tokens beyond EOS
+   * are computed and discarded by the caller. KV overshoot is harmless (seqPos
+   * governs reads) but SSM/conv state is NOT rewindable — continuing the same
+   * context past an intra-window EOS requires a re-prefill from that point.
+   *
+   * Evidence base: measured FLAT on M4 Max/Metal (results.jsonl r13-E2 /
+   * r14-E2v2 — depth-2 pipelining already hides submit+readback there);
+   * targeted at Dawn/Vulkan where the submit roundtrip is 52µs and decode is
+   * dispatch/driver-bound (A5000 gate, arXiv:2604.02344). See
+   * docs/design/dispatch-collapse-campaign.md §3.
+   */
+  submitGreedyDecodeWindow(firstToken: number | null, steps: number, slot: number): void;
+  /** Get (or lazily create) entry's per-step uniform/bind-group variant. */
+  private getWindowVariant;
+  /** Read back the `steps` token ids produced by the window that used `slot`. */
+  readDecodeWindow(slot: number, steps: number): Promise<Uint32Array>;
   reset(): void;
   /**
    * Diagnostic: dispatch ONLY the first kernel (EmbeddingInt4) using the
@@ -1744,12 +1332,235 @@ declare class Executor {
   private allocateActivationBuffers;
   private allocateSSMStateBuffers;
   private allocateKVCacheBuffers;
+  /** f16 SSM-state kernels are selected on Dawn with f16 support (not WebKit). */
+  private get usesF16Ssm();
+  /**
+   * Batched-decode state (GERBIL_BATCH=N): per-slot SSM/conv state pools, the
+   * per-row positions/seq_lens buffers, the sampled-token buffer + readback
+   * ring, and batch-widened buffers for the lm-head tail (SliceLastRow output
+   * and logits become [N, ...]).
+   *
+   * SSM pool slot stride: the f16 MambaSSM kernel indexes its state buffer in
+   * f16 ELEMENTS (the buffer is f32-sized with the upper half unused), so its
+   * pool slot stride is elems*2 bytes; conv state (f32 kernels) uses the full
+   * f32 byte size. The batched kernels compute `slot * elems` in their own
+   * element space, so the pool stride must match each kernel's element width.
+   */
+  private allocateBatchState;
   private resolveShapes;
   private getBuffer;
+  /**
+   * Batch-path buffer resolution: lm-head tail tensors use their [B, ...]
+   * widened buffers, ssm_state tensors bind the per-slot pool, everything
+   * else falls through to the regular buffer maps.
+   */
+  private getBatchBuffer;
+  /**
+   * True when this node's KV traffic goes through the paged path: the flag is
+   * on AND the node actually touches a kv_cache tensor (KVCacheAppend writes
+   * one; self-attention reads one as its K input). SSM/conv state and
+   * ViT/cross-attention over plain activations never match — on hybrid models
+   * only the attention layers page, exactly as the design requires.
+   */
+  private usesPagedKV;
+  /**
+   * Paged KV only: make sure blocks are mapped for logical positions
+   * [0, seqPos + T) BEFORE this forward's dispatches are submitted.
+   * queue.writeBuffer is queue-ordered, so the (rare — once per 16 tokens)
+   * table upload always lands ahead of the submits that read it, including in
+   * the pipelined decode path with PIPELINE_DEPTH steps in flight.
+   */
+  private preparePagedKV;
+  /** Runtime context for batched dispatches (positions live in buffers). */
+  private batchRuntimeCtx;
+  /**
+   * Shapes for the batched step: every "T" dimension is the batch width, and
+   * the lm-head tail tensors (statically [1, ...] in the graph) widen to
+   * [B, ...] — every row IS a last row on the batch path.
+   */
+  private resolveBatchShapes;
+  /**
+   * Build the batched dispatch-entry list: one lockstep decode step for all
+   * batchSize rows. Row-independent ops (embedding, norms, elementwise) keep
+   * their prefill kernels at T=B; linear layers run the batched INT4 GEMM;
+   * every position/state-dependent op swaps to its batch-indexed variant
+   * (paged attention + append via per-row block-table rows, RoPE via the
+   * positions buffer, conv/SSM via the per-slot state pool).
+   */
+  private buildBatchEntries;
+  /**
+   * Batched-path fusion driver (Phase 4). Ports the single-sequence decode
+   * fusions onto `batchEntries`: identical math (the fused kernels reproduce
+   * the unfused chain operation-for-operation — exact-tier GEMM reductions
+   * keep the V2 order, elementwise prologues/epilogues keep the registry
+   * kernels' formulas), strictly fewer dispatches. `GERBIL_BATCH_FUSE`
+   * selects a subset for A/B measurement: unset/"all" = every pass,
+   * "none" = none, or a comma list of pass names.
+   */
+  private fuseBatchDecodeEntries;
+  /**
+   * Batch port of fuseSwiGLUDecodeEntries: gate MatMulInt4 + up MatMulInt4 +
+   * elementwise SwiGLU → ONE fused batched GEMM (saves 2 dispatches per MLP
+   * block and the gate/up activation round-trips).
+   */
+  private fuseBatchSwiGLUMLPEntries;
+  /**
+   * Batch port of fuseDualMatVecDecodeEntries: two adjacent MatMulInt4s
+   * sharing one input and identical K/N/group_size (q+gate, k+v) → ONE dual
+   * batched GEMM dispatch (wid.y selects the projection — per-projection
+   * math unchanged).
+   */
+  private fuseBatchDualMatVecEntries;
+  /**
+   * Batch port of fuseDualKVCacheAppendEntries: adjacent K+V paged appends →
+   * ONE BATCHED_PAGED_DUAL_KV_APPEND dispatch (pure memcpys — identical
+   * writes, one dispatch per attention layer saved).
+   */
+  private fuseBatchDualKVAppendEntries;
+  /**
+   * Batch port of fuseGatedOProjDecodeEntries ("sigmoid": SigmoidGate →
+   * o_proj) and fuseSwiGLUGatedProjDecodeEntries ("swiglu": Mamba SwiGLU →
+   * out_proj): the elementwise gate is recomputed inside the GEMM's input
+   * load with the registry kernel's exact formula — one dispatch per layer
+   * saved plus the gated-activation round-trip.
+   */
+  private fuseBatchGatedProjEntries;
+  /**
+   * Batch port of fuseDualRMSNormRoPEDecodeEntries: [q_norm, k_norm, RoPE]
+   * → ONE BATCHED_DUAL_RMSNORM_ROPE dispatch (per-row rotation position from
+   * the positions buffer). Saves 2 dispatches per full-attention layer.
+   */
+  private fuseBatchDualRMSNormRoPEEntries;
+  /**
+   * Reset ALL batch slots for a new lockstep generation: frees every
+   * sequence's KV blocks, zeroes the single-sequence SSM state (the prefill
+   * staging area), and clears per-slot lengths. State-pool slots need no
+   * zeroing — finishBatchSlot overwrites a slot in full before it is read.
+   */
+  resetBatch(): void;
+  /**
+   * Route the single-sequence forward() path at batch slot `slot`: paged KV
+   * writes/reads use the slot's block-table row (RuntimeContext.tableBase) and
+   * SSM state accumulates in the singleton staging buffers (zeroed).
+   * Call once per prompt, then forward(promptIds), then finishBatchSlot().
+   */
+  beginBatchSlot(slot: number): void;
+  /**
+   * Adopt the just-prefilled sequence into `slot`: records its length, copies
+   * the singleton SSM/conv state into the slot's pool rows (KV already lives
+   * in the slot's block-table row via tableBase), and zeroes the singleton
+   * staging state for the next prefill.
+   */
+  finishBatchSlot(slot: number): void;
+  /** Per-slot token counts (prompt + generated) on the batch path. */
+  get batchSlotLengths(): Uint32Array;
+  /**
+   * Submit one lockstep batched decode step (pipelined — does not await).
+   * `tokens` feeds input_ids on the first step; pass null afterwards to chain
+   * the previous step's sampled ids into input_ids ON the GPU. Sampled ids
+   * land in the `slot` readback (read one step behind via readBatchTokens).
+   */
+  submitBatchDecodeStep(tokens: Uint32Array<ArrayBuffer> | null, slot: number): void;
+  /** Read the sampled ids produced by the batched step that used `slot`. */
+  readBatchTokens(slot: number): Promise<Uint32Array>;
+  /** Batch entries in effect for the current lane-adapter state. */
+  private get activeBatchEntries();
+  /** Number of adapters registered for per-lane batched decode. */
+  get batchAdapterCount(): number;
+  /**
+   * Register a LoRA adapter for per-lane batched decode and return its integer
+   * adapter id (assign lanes via {@link setBatchLaneAdapters}). Factors are
+   * packed into per-adapted-node GPU buffers ONCE — every lane running this
+   * adapter reads the same factors. Fused query+gate deltas are expanded with
+   * the same deinterleave the single-sequence overlay uses.
+   *
+   * Phase-1 constraint: every adapter adapting a given linear must share that
+   * node's LoRA rank (the packed factor arena is fixed-stride; mixed ranks are
+   * deferred).
+   */
+  registerBatchAdapter(deltas: LoRADelta[]): number;
+  /** Drop every registered batch adapter and free the overlay's GPU buffers. */
+  clearBatchAdapters(): void;
+  /**
+   * Assign each batch lane its adapter: `ids[b]` is a registered adapter id or
+   * -1 for the bare base. Uploads the per-lane adapter_ids buffer (the
+   * positions/seq_lens per-row pattern) and switches the step's entry list to
+   * the LoRA overlay iff any lane carries an adapter — an all-base assignment
+   * runs the untouched plain batch entries at zero extra cost.
+   */
+  setBatchLaneAdapters(ids: ArrayLike<number>): void;
+  /** Free the batch-LoRA overlay's GPU buffers (factors, maps, tmp, uniforms). */
+  private destroyBatchLoraBuffers;
+  /**
+   * (Re)build the per-lane LoRA overlay: pack every registered adapter's
+   * factors per adapted node, and derive `batchEntriesLoRA` from the fused
+   * batch entry list with SELECTIVE unfusing — every fused group that covers
+   * no adapted linear stays exactly as the plain batch path runs it; groups
+   * covering an adapted node fall back to their pre-fusion per-node entries
+   * (token-exact by the Phase 2/4 derivation discipline) with the per-lane
+   * `[down, up]` gather pair spliced right after each adapted node, so the
+   * corrected output is live before any consumer reads it.
+   */
+  private rebuildBatchLoraOverlay;
+  /** Total physical KV blocks in the paged pool (admission-control bound). */
+  get kvTotalBlocks(): number;
+  /** KV blocks currently unallocated. */
+  get kvFreeBlocks(): number;
+  /** Tokens per KV block (admission-control block-count math). */
+  get kvBlockSizeTokens(): number;
+  /** Blocks a single sequence may map (== ceil(maxSeqLen / blockSize)). */
+  get kvMaxBlocksPerSeq(): number;
+  /** Effective context length (scheduler admission math). */
+  get maxSequenceLength(): number;
+  /**
+   * Retire a batch lane: free its KV blocks and zero its length so masked
+   * steps treat the slot as empty (seq_lens[slot] = 0). The SSM pool row
+   * needs no cleanup — re-admission overwrites it in full (finishBatchSlot).
+   */
+  retireBatchSlot(slot: number): void;
+  /**
+   * Seed `slot`'s next input token (the first token sampled from its prefill
+   * logits). Written into the sampled-ids buffer so the next masked step's
+   * on-GPU chain copy propagates it into input_ids. queue.writeBuffer is
+   * queue-ordered: it lands AFTER any in-flight step's argmax write to the
+   * same word and BEFORE the next submitted step's chain copy — correct even
+   * with PIPELINE_DEPTH steps in flight.
+   */
+  injectBatchToken(slot: number, token: number): void;
+  /**
+   * Submit one MASKED batched decode step (the scheduler's step; pipelined —
+   * does not await). Only lanes with `active[b] != 0` advance: inactive lanes
+   * get positions=0 / seq_lens=0, which masks their KV appends (kernel guard)
+   * and clamps their attention window to nothing; their other row-local ops
+   * compute garbage that stays confined to their rows/state slots and is
+   * fully overwritten on re-admission.
+   *
+   * The step's dispatch width is dynamic: kernels take their batch dimension
+   * from the runtime context, so only rows [0, maxActiveSlot] are dispatched
+   * (GEMM b-tiles may cover a few dead rows past the last active one —
+   * in-bounds stale writes that are never read). Input tokens always chain
+   * from the sampled-ids buffer on the GPU; newly admitted lanes are seeded
+   * via injectBatchToken. Sampled ids land in the `slot` readback (read one
+   * step behind via readBatchTokens).
+   */
+  submitBatchDecodeStepMasked(active: Uint8Array, slot: number): void;
+  /** Write the batched-argmax uniform once per batch session (invariant). */
+  private writeBatchArgmaxParams;
+  private requireBatch;
   /**
    * Detect gate_proj + up_proj + SwiGLU patterns in decode entries and replace
    * with a single fused SwiGLUMatVec dispatch. Saves 2 dispatches per MLP block.
    */
+  /**
+   * Fuse [ResidualRMSNorm, gate MatMulInt4, up MatMulInt4, SwiGLU] → ONE
+   * NormSwiGLUMatVec dispatch. The kernel computes the residual sum + RMS in a
+   * prologue (workgroup 0 persists the residual sum for the downstream residual
+   * chain) and normalizes the activation on the fly, so the norm dispatch AND
+   * the normed tensor's write+read roundtrip disappear. INT4-only; falls back
+   * when the device can't bind 11 storage buffers. Windows it skips fall
+   * through to fuseSwiGLUDecodeEntries.
+   */
+  private fuseNormSwiGLUDecodeEntries;
   private fuseSwiGLUDecodeEntries;
   /**
    * Fuse two adjacent INT4 projections that share the same input activation and
@@ -1808,45 +1619,797 @@ declare class Executor {
    */
   private fuseSwiGLUGatedProjDecodeEntries;
   /**
-   * Fuse two adjacent per-row RMSNorms sharing hidden_size + eps into a single
-   * DualRMSNorm dispatch (e.g. the per-head q_norm and k_norm in full-attention
-   * decode). One workgroup still handles one row; the fused grid just spans both
-   * inputs' rows, so each row's reduction is unchanged — numerically identical to
-   * two separate RMSNorm dispatches. One round-trip saved per fused pair.
-   *
-   * WebKit risk: low — same single-workgroup reduction as the proven RMSNorm
-   * kernel, only the row→input routing is added.
+   * Fuse two adjacent per-row RMSNorms sharing hidden_size + eps into a single
+   * DualRMSNorm dispatch (e.g. the per-head q_norm and k_norm in full-attention
+   * decode). One workgroup still handles one row; the fused grid just spans both
+   * inputs' rows, so each row's reduction is unchanged — numerically identical to
+   * two separate RMSNorm dispatches. One round-trip saved per fused pair.
+   *
+   * WebKit risk: low — same single-workgroup reduction as the proven RMSNorm
+   * kernel, only the row→input routing is added.
+   */
+  /**
+   * Fuse [CausalConv1dSiLU|CausalConv1dGated → ConvStateUpdate] into one
+   * dispatch (decode entries only). At T=1 the conv read and the rolling-state
+   * write for a channel live in the same thread, so the fused kernel is
+   * race-free; prefill (T>1) keeps the two-dispatch path.
+   */
+  private fuseConvStateUpdateDecodeEntries;
+  /**
+   * Fuse [per-head q_norm RMSNorm, k_norm RMSNorm, in-place RoPE] into ONE
+   * DualRMSNormRoPE dispatch. Numerically identical (norm then rotate, same
+   * math); requires head_dim <= 256 and RoPE operating in-place on exactly the
+   * two norm outputs. Saves 2 dispatches per full-attention layer — a mobile
+   * (WebKit submit-per-dispatch) win, desktop-neutral.
+   */
+  /**
+   * Fuse [Add → RMSNorm] into a single ResidualRMSNorm dispatch: the add's sum
+   * is still materialized (sum_output — downstream residual chain reads it) and
+   * the norm result is written in the same dispatch. Numerically identical.
+   */
+  private fuseAddRMSNormDecodeEntries;
+  private fuseDualRMSNormRoPEDecodeEntries;
+  private fuseDualRMSNormDecodeEntries;
+  /**
+   * Gather buffer entries for a bind group, matching the kernel spec's binding layout.
+   * Uses the pre-allocated inputIdsBuffer for the "input_ids" tensor.
+   */
+  private gatherBuffers;
+  /** Lazily allocate a scratch storage buffer at least `minBytes` large. */
+  private getBindingScratchBuffer;
+}
+//#endregion
+//#region src/gpu/batch/scheduler.d.ts
+/** Options for a single scheduled request. */
+interface ServeOptions {
+  /** Max new tokens (clamped to context; default 128). */
+  maxTokens?: number;
+  stopSequences?: string[];
+  systemPrompt?: string;
+  /** Greedy-only in Phase 5: temperature must be 0 (or omitted). */
+  sampling?: {
+    temperature?: number;
+  };
+  /**
+   * Registered adapter name this request decodes with (SGMV — requires
+   * `GERBIL_BATCH_LORA=1` and a prior `registerAdapter` call on the engine);
+   * undefined = bare base. Requests with different adapters (or none) decode
+   * concurrently over the shared base, each token-exact vs a solo run with
+   * that adapter loaded.
+   */
+  adapter?: string;
+  /** Streamed per-token callback (decoded text piece). */
+  onToken?: (token: string, meta: {
+    requestId: number;
+    tokenId: number;
+    generated: number;
+  }) => void;
+}
+/** Per-request result + serving timings (all performance.now() ms). */
+interface ServeResult {
+  requestId: number;
+  text: string;
+  tokenIds: number[];
+  tokensGenerated: number;
+  finishReason: "eos" | "max_tokens" | "stop_sequence";
+  /** The adapter name the request decoded with (echoed through), if any. */
+  adapter?: string;
+  /** submit() call time. */
+  submittedAt: number;
+  /** Admission into a batch slot (prefill start). */
+  admittedAt: number;
+  /** First token available (end of prefill). */
+  firstTokenAt: number;
+  finishedAt: number;
+  /** Time-to-first-token from submission (queue wait + prefill). */
+  ttftMs: number;
+  e2eMs: number;
+}
+/** Wiring the engine hands the scheduler (see WebGPUEngine.createScheduler). */
+interface SchedulerHost {
+  executor: Executor;
+  encodeChat(messages: ChatMessage[]): number[];
+  decodeToken(id: number): string;
+  eosTokenId: number | null;
+  eotTokenId: number | null;
+  /** Vocab-prune remap for CPU-sampled tokens (identity when unpruned). */
+  remapToken(id: number): number;
+  /**
+   * Resolve a registered batch-adapter name to its executor adapter id +
+   * parsed deltas. Must throw a clear error for unregistered names (surfaced
+   * at submit() time, before the request is queued).
+   */
+  resolveAdapter(name: string): {
+    id: number;
+    deltas: LoRADelta[];
+  };
+  /** Serialize against generate()/embed() on the same engine. */
+  acquireLock(): Promise<() => void>;
+}
+interface SchedulerStats {
+  submitted: number;
+  completed: number;
+  stepsSubmitted: number;
+  prefillChunks: number;
+  tokensGenerated: number;
+  /** Wall-clock ms the serving loop was live (work outstanding). */
+  busyMs: number;
+  peakActiveLanes: number;
+}
+declare class RequestScheduler {
+  private readonly host;
+  private readonly batchSize;
+  private readonly maxSeqLen;
+  private readonly blockSize;
+  private readonly prefillChunk;
+  /** Free KV blocks kept unreserved as safety headroom. */
+  private readonly blockHeadroom;
+  private nextId;
+  private queue;
+  /** slot → occupying request (prefilling or decoding). */
+  private slots;
+  /** Sum of blocksReserved across live (admitted, unfinished) requests. */
+  private reservedBlocks;
+  private prefilling;
+  private 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.
+   */
+  private lastLaneAdapterIds;
+  private stepCounter;
+  private loop;
+  private closed;
+  private stats;
+  constructor(host: SchedulerHost, options?: {
+    prefillChunkTokens?: number;
+  });
+  /**
+   * Submit a request; resolves with the full result when it finishes.
+   * Tokens stream through options.onToken as they are decoded.
+   */
+  submit(prompt: string | ChatMessage[], options?: ServeOptions): Promise<ServeResult>;
+  /** Resolves when every submitted request has completed. */
+  drain(): Promise<void>;
+  /** Stop accepting requests; resolves when in-flight work drains. */
+  close(): Promise<void>;
+  getStats(): SchedulerStats;
+  private pump;
+  private hasWork;
+  private activeMask;
+  /** The serving loop. Holds the engine generation lock while live. */
+  private run;
+  /**
+   * 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.
+   */
+  private syncLaneAdapters;
+  /**
+   * 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.
+   */
+  private admit;
+  /**
+   * 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.
+   */
+  private prefillChunkStep;
+  /** Read the oldest in-flight step and deliver its tokens. */
+  private readStep;
+  /** Append one generated token; finish + retire the lane when terminal. */
+  private consumeToken;
+  /** Retire the lane immediately: free KV blocks, open the slot, resolve. */
+  private finish;
+}
+//#endregion
+//#region src/gpu/batch/swarm.d.ts
+/** Per-request options a swarm sub-task may set (the member picks the adapter). */
+type SwarmTaskOptions = Omit<ServeOptions, "adapter">;
+/** One planned sub-task: which member decodes which prompt. */
+interface SwarmTask {
+  /** Member name (a key of the swarm's `members`). */
+  member: string;
+  prompt: string | ChatMessage[];
+  /** Per-task overrides merged over the run's options. */
+  options?: SwarmTaskOptions;
+}
+/** One member's completed sub-task (plan order is preserved). */
+interface SwarmMemberResult {
+  member: string;
+  result: ServeResult;
+}
+/**
+ * Swarm configuration.
+ *
+ * @template R The reduced result type (defaults to the member-keyed map the
+ *   default reduce produces).
+ */
+interface SwarmOptions<R = Record<string, ServeResult>> {
+  /**
+   * Member name → adapter source (`hf:owner/repo`, URL, or `file:./dir`), or
+   * null for a member that decodes on the bare base. Every non-null source is
+   * registered on the engine (factors packed into shared GPU buffers once).
+   */
+  members: Record<string, string | null>;
+  /**
+   * input → sub-tasks routed to members. Default: broadcast the input to
+   * every member (one sub-task each, declaration order).
+   */
+  plan?: (input: string, members: string[]) => SwarmTask[] | Promise<SwarmTask[]>;
+  /**
+   * Joined sub-results → final answer. Default: a member-keyed map of
+   * ServeResults (a duplicated member's later tasks get `name#2`, `name#3`…).
+   */
+  reduce?: (results: SwarmMemberResult[]) => R | Promise<R>;
+}
+/**
+ * A swarm handle: registered members + plan/reduce over the engine's
+ * scheduler. Create via {@link WebGPUEngine.createSwarm}.
+ */
+declare class Swarm<R = Record<string, ServeResult>> {
+  private readonly scheduler;
+  private readonly memberSources;
+  private readonly plan;
+  private readonly reduce;
+  constructor(scheduler: RequestScheduler, options: SwarmOptions<R>);
+  /** Member names, declaration order. */
+  get members(): string[];
+  /**
+   * 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).
+   */
+  run(input: string, options?: SwarmTaskOptions): Promise<R>;
+  /**
+   * 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: string, prompt: string | ChatMessage[], options?: SwarmTaskOptions): Promise<ServeResult>;
+  private submitFor;
+}
+//#endregion
+//#region src/gpu/sampler.d.ts
+/**
+ * CPU-side token sampling from logits.
+ *
+ * Applies temperature, top-k, and top-p (nucleus) filtering,
+ * then samples from the resulting probability distribution.
+ *
+ * Uses typed arrays and min-heap for zero-allocation top-K selection.
+ * For vocab_size ~152K with topK=50, this avoids creating 152K JS tuples.
+ */
+interface SamplingParams {
+  temperature?: number;
+  topK?: number;
+  topP?: number;
+  repetitionPenalty?: number;
+  /**
+   * Seed for the sampling RNG. When set, sampled decoding is reproducible:
+   * the same params object draws a deterministic random stream (seeded on its
+   * first use — pass a fresh options object per generation for run-to-run
+   * reproducibility). Unset: Math.random() (non-deterministic, the default).
+   */
+  seed?: number;
+}
+//#endregion
+//#region src/gpu/vision-preprocess.d.ts
+/**
+ * Host-side vision preprocessing for the Qwen3.5 ViT.
+ *
+ * The learned position embeddings (bilinear-interpolated over the patch grid)
+ * and the 2D rotary cos/sin tables are functions of the image grid (t, h, w)
+ * ONLY — not of the model weights or pixel values. They are cheap to compute on
+ * the CPU and fed to the GPU graph as input activations, keeping the graph to
+ * weight-dependent math while staying byte-identical to HF transformers.
+ *
+ * Ports (verified against transformers 5.12 vision_utils.py + modeling_qwen3_5):
+ *   - get_vision_bilinear_indices_and_weights  → buildPosEmbeds()
+ *   - get_vision_position_ids                  → buildPositionIds()
+ *   - Qwen3_5VisionRotaryEmbedding             → buildRotaryCosSin()
+ *
+ * Patch ordering: both the pos-embed gather and the position ids reorder patches
+ * into spatial_merge_size×spatial_merge_size groups, matching the HF image
+ * processor's output ordering, so the merger's [N,h]→[N/u,h*u] reshape lines up.
+ */
+interface VisionGridConfig {
+  hiddenSize: number;
+  numHeads: number;
+  numPositionEmbeddings: number;
+  spatialMergeSize: number;
+  ropeTheta?: number;
+}
+interface VisionPositionTensors {
+  /** [N, hidden_size] bilinear-interpolated learned position embeddings. */
+  posEmbeds: Float32Array;
+  /** [N, head_dim] rotary cosines. */
+  cos: Float32Array;
+  /** [N, head_dim] rotary sines. */
+  sin: Float32Array;
+  numPatches: number;
+}
+/**
+ * Build bilinear-interpolated learned position embeddings [N, hidden].
+ * posEmbedTable is the raw pos_embed.weight [num_position_embeddings, hidden].
+ */
+declare function buildPosEmbeds(gridTHW: [number, number, number], posEmbedTable: Float32Array, cfg: VisionGridConfig): Float32Array;
+/**
+ * Build the reordered (row, col) position ids [N, 2] for rotary, matching
+ * get_vision_position_ids.
+ */
+declare function buildPositionIds(gridTHW: [number, number, number], merge: number): Int32Array;
+/**
+ * Build rotary cos/sin tables [N, head_dim] from position ids, matching
+ * Qwen3_5VisionRotaryEmbedding + the cat((rotary, rotary)) in VisionModel.forward.
+ *
+ * rotary_pos_emb(position_ids) = (position_ids[..,None] * inv_freq).flatten(1)
+ *   where inv_freq has length (head_dim/2)/2 = head_dim/4, computed over dim=head_dim/2.
+ * For each token the two position components (h, w) each produce head_dim/4 freqs,
+ * concatenated → head_dim/2, then duplicated → head_dim for cos/sin.
+ */
+declare function buildRotaryCosSin(positionIds: Int32Array, headDim: number, theta?: number): {
+  cos: Float32Array;
+  sin: Float32Array;
+  numPatches: number;
+};
+/**
+ * Build all host position tensors for a single image grid in one call.
+ */
+declare function buildVisionPositionTensors(gridTHW: [number, number, number], posEmbedTable: Float32Array, cfg: VisionGridConfig): VisionPositionTensors;
+interface Gemma4VisionGridConfig {
+  hiddenSize: number;
+  numHeads: number;
+  headDim: number;
+  ropeTheta: number;
+  poolingKernelSize: number;
+}
+interface Gemma4VisionPositionTensors {
+  /** [N, hidden] axial position embeddings (table[0][x] + table[1][y]). */
+  posEmbeds: Float32Array;
+  /** [N, headDim] axial rotary cosines. */
+  cos: Float32Array;
+  /** [N, headDim] axial rotary sines. */
+  sin: Float32Array;
+  /** [Np, N] average-pooling matrix (1/k² in-cell, 0 elsewhere). */
+  poolMatrix: Float32Array;
+  /** number of patches N (= gridH*gridW). */
+  numPatches: number;
+  /** number of pooled (soft) tokens Np (= ceil(gridH/k)*ceil(gridW/k)). */
+  numPooled: number;
+}
+/**
+ * Build axial learned position embeddings [N, hidden] from the [2, posSize, hidden]
+ * table: pos[p] = table[0][x_p] + table[1][y_p]. Direct lookup, no interpolation
+ * (HF F.embedding on clamped positions).
+ */
+declare function buildGemma4PosEmbeds(gridH: number, gridW: number, posEmbedTable: Float32Array,
+// [2, posSize, hidden] flattened
+hidden: number, posSize: number): Float32Array;
+/**
+ * Build the 2D axial rotary cos/sin tables [N, headDim].
+ *   spatial_dim = headDim / 2;  inv_freq[j] = 1/theta^((2j)/spatial_dim), j in [0, spatial_dim/2)
+ *   per spatial dim: f = pos * inv_freq (spatial_dim/2 values); emb = cat(f, f) (spatial_dim values)
+ *   cos/sin = cat([emb_x, emb_y]) → headDim values, layout [fx,fx,fy,fy].
+ * Applied with the global-half rotate_half kernel (ApplyRotaryEmb), which computes
+ * out = x*cos + rotate_half(x)*sin element-wise — exact for this layout.
+ */
+declare function buildGemma4RotaryCosSin(gridH: number, gridW: number, headDim: number, theta: number): {
+  cos: Float32Array;
+  sin: Float32Array;
+};
+/**
+ * Build the [Np, N] average-pooling matrix for k×k spatial pooling over the real
+ * (unpadded) grid, matching modeling_gemma4's kernel_idxs/one_hot pooling:
+ *   cell(p) = floor(x_p/k) + ceil(gridW/k) * floor(y_p/k)
+ *   poolMatrix[cell, p] = 1/k²  (so pooled = poolMatrix @ hidden = mean over the k×k block)
+ * Np = ceil(gridH/k) * ceil(gridW/k). Each pooled cell averages exactly the patches
+ * that fall in it (edge cells with fewer than k² patches still divide by k², matching
+ * HF's fixed 1/k² normalization).
+ */
+declare function buildGemma4PoolMatrix(gridH: number, gridW: number, k: number): {
+  poolMatrix: Float32Array;
+  numPooled: number;
+};
+/**
+ * Build all Gemma 4 vision host tensors for one image grid in one call.
+ * `posEmbedTable` is the raw [2, posSize, hidden] flattened table.
+ */
+declare function buildGemma4VisionPositionTensors(gridH: number, gridW: number, posEmbedTable: Float32Array, posSize: number, cfg: Gemma4VisionGridConfig): Gemma4VisionPositionTensors;
+/** Gemma 4 image processor config (from processor_config.json). */
+declare const GEMMA4_IMAGE_PROCESSOR: ImageProcessorConfig;
+interface Gemma4PreprocessedImage {
+  /** Flattened patches [N, 3·patch²] row-major (row-major patch grid). */
+  patches: Float32Array;
+  /** Patch grid (gridH, gridW). */
+  gridHW: [number, number];
+}
+/**
+ * Preprocess a decoded RGB image for the Gemma 4 ViT: aspect-preserving resize so
+ * the patch grid is ≤ max_soft_tokens·k² patches and H,W divisible by k·patch,
+ * rescale ×1/255 (no normalize), patchify row-major into [N, 3·16·16].
+ *
+ * @param pixels row-major HWC RGB (0..255), length width*height*3.
+ */
+declare function preprocessImageGemma4(pixels: Float32Array | Uint8ClampedArray | Uint8Array, width: number, height: number, maxSoftTokens?: number, poolingKernelSize?: number, patchSize?: number): Gemma4PreprocessedImage;
+interface ImageProcessorConfig {
+  patchSize: number;
+  temporalPatchSize: number;
+  mergeSize: number;
+  imageMean: [number, number, number];
+  imageStd: [number, number, number];
+  /** rescale factor applied to raw 0..255 pixels before normalization (1/255). */
+  rescaleFactor: number;
+  /** min total pixels after resize (shortest_edge). */
+  minPixels: number;
+  /** max total pixels after resize (longest_edge). */
+  maxPixels: number;
+}
+declare const QWEN3_5_IMAGE_PROCESSOR: ImageProcessorConfig;
+interface PreprocessedImage {
+  /** Flattened patches [N, 1536] in the spatial-merge order encodeImage expects. */
+  patches: Float32Array;
+  /** (t, h, w) patch grid. t=1 for a single image, h/w in patch units. */
+  gridTHW: [number, number, number];
+}
+/**
+ * Qwen2-VL smart-resize: round H and W to multiples of factor=patch*merge,
+ * keeping aspect ratio and clamping the total pixel budget to [minPixels, maxPixels].
+ * Matches transformers.models.qwen2_vl.image_processing.smart_resize.
+ */
+declare function smartResize(height: number, width: number, factor: number, minPixels: number, maxPixels: number): [number, number];
+/**
+ * Preprocess a decoded RGB image into the [N, 1536] patch tensor + grid_thw that
+ * `encodeImage()` expects, matching the HF Qwen2-VL image processor:
+ *   smart_resize → rescale (×1/255) → normalize → temporal-pair (×temporal_patch_size)
+ *   → patchify into spatial_merge×spatial_merge blocks → flatten to [N, C·T·P·P].
+ *
+ * @param pixels row-major HWC RGB, length width*height*3. Values 0..255 (default)
+ *   or already 0..1 if `rescaled` is true.
+ * @param width  source pixel width
+ * @param height source pixel height
+ */
+declare function preprocessImage(pixels: Float32Array | Uint8ClampedArray | Uint8Array, width: number, height: number, cfg?: ImageProcessorConfig, rescaled?: boolean): PreprocessedImage;
+declare function buildMRoPEPositionIds(inputIds: Int32Array | Uint32Array | number[], imageGrids: Array<[number, number, number]>, imageTokenId: number, mergeSize: number): Int32Array;
+/**
+ * Per-pair frequency→dimension assignment for interleaved M-RoPE, matching
+ * Qwen3_5TextRotaryEmbedding.apply_interleaved_mrope. For pair index i in
+ * [0, sum(section)) the position component is section-cyclic: T,H,W,T,H,W,...
+ * but each component capped at its section count. Returns an array of length
+ * (rope_dim/2) with values 0=T, 1=H, 2=W.
+ */
+declare function mropeFreqDims(mropeSection: [number, number, number]): Int32Array;
+/**
+ * Build the interleaved-M-RoPE cos/sin tables [seq, rope_dim] from 3D position
+ * ids, matching Qwen3_5TextRotaryEmbedding.forward:
+ *   freqs[d][i] = pos[d] * inv_freq[i],  inv_freq[i] = 1/theta^(2i/rope_dim)
+ *   freq[i] picks component mropeFreqDims[i]; emb = cat(freqs, freqs).
+ * cos/sin have length seq*rope_dim. For text-only (all 3 pos rows equal) this
+ * reduces exactly to standard 1D partial RoPE.
+ *
+ * @param positionIds3 [3, seq] as produced by buildMRoPEPositionIds.
+ * @param ropeDim      number of rotated dims per head (head_dim * partial_factor).
+ */
+declare function buildMRoPECosSin(positionIds3: Int32Array, seq: number, ropeDim: number, theta: number, mropeSection: [number, number, number]): {
+  cos: Float32Array;
+  sin: Float32Array;
+};
+//#endregion
+//#region src/gpu/defaults.d.ts
+/**
+ * Default model per capability. Kept in its own tiny module (no heavy imports)
+ * so the React hooks can resolve defaults without statically pulling in the GPU
+ * engine — they import the engine dynamically to stay light.
+ */
+declare const DEFAULT_MODELS: {
+  /** Text generation (also the vision-capable checkpoint). */
+  readonly text: "mlx-community/Qwen3.5-0.8B-4bit";
+  /** Image understanding — same checkpoint, vision tower built on demand. */
+  readonly vision: "mlx-community/Qwen3.5-0.8B-4bit";
+  /** Text embeddings. */
+  readonly embedding: "mlx-community/embeddinggemma-300m-4bit";
+  /** Text-to-speech (Apache-2.0; LFM2-350M backbone + NanoCodec). Small/fast default. */
+  readonly tts: "nineninesix/kani-tts-450m-0.2-ft";
+  /**
+   * Selectable many-voices TTS (OuteTTS-1.0-0.6B: Qwen3-0.6B codec-LM + DAC.speech).
+   * Pass this as the `repo`/`model` to engine.speak()/useTTS to route to OuteTTS.
    */
+  readonly ttsOute: "OuteAI/OuteTTS-1.0-0.6B";
   /**
-   * Fuse [CausalConv1dSiLU|CausalConv1dGated → ConvStateUpdate] into one
-   * dispatch (decode entries only). At T=1 the conv read and the rolling-state
-   * write for a channel live in the same thread, so the fused kernel is
-   * race-free; prefill (T>1) keeps the two-dispatch path.
+   * Selectable describe-your-voice TTS (Parler-TTS-mini-v1: Flan-T5 encoder +
+   * cross-attending decoder LM + dac_44khz). Pass this as the `repo`/`model` to
+   * engine.speak()/useTTS with a `describeVoice` natural-language description.
    */
-  private fuseConvStateUpdateDecodeEntries;
+  readonly ttsParler: "parler-tts/parler-tts-mini-v1";
+  /** Speech-to-text. */
+  readonly stt: "UsefulSensors/moonshine-base";
+};
+declare const OUTETTS_ASSETS: {
+  /** Folded DAC.speech.v1.0 encoder+decoder weights (prep-dac-speech.py output). */
+  readonly codecWeightsURL: "https://pub-0522ecec25fc412bb35a523f3e3f63c6.r2.dev/tryhamster/gerbil-outetts-assets/dac-speech-folded.safetensors";
+  /** Base URL for the preset speaker JSONs (`{name}.json`). */
+  readonly speakersBaseURL: "https://pub-0522ecec25fc412bb35a523f3e3f63c6.r2.dev/tryhamster/gerbil-outetts-assets/speakers";
+  /** The default preset voice. */
+  readonly defaultVoice: "en-female-1-neutral";
+};
+/**
+ * Bundled OuteTTS preset voices.
+ *
+ * Provenance (honest labelling):
+ *  - `en-female-1-neutral` is the ONE AUTHENTIC OuteAI voice — the OuteTTS v3 bundled
+ *    default speaker (default_speakers/en-female-1-neutral), copied verbatim.
+ *  - `gerbil-voice-2..6` are DERIVED voices: distinct timbres produced by running
+ *    pitch/tempo-varied renderings of that authentic clip back through the REAL
+ *    DAC.speech encode + prosody pipeline (scripts/engine/stage-outetts-assets.py).
+ *    They are genuine DAC-encoded OuteSpeakers, but they are NOT OuteAI's own
+ *    `en-male-*` voices, so they are not labelled as such. (Earlier builds mislabelled
+ *    them as `en-male-2-neutral` etc.; renamed for honesty.)
+ */
+declare const OUTETTS_PRESET_VOICES: readonly ["en-female-1-neutral", "gerbil-voice-2", "gerbil-voice-3", "gerbil-voice-4", "gerbil-voice-5", "gerbil-voice-6"];
+/**
+ * True when `repo`/`architecture` identify a text-to-speech checkpoint that must
+ * run through a dedicated native TTS engine (KaniTTS, OuteTTS, or Parler-TTS)
+ * rather than the single-graph base text loader. Mirrors the routing used by
+ * `WebGPUEngine.speak()` / `Gerbil.ensureNativeTTSEngine`:
+ *   - Parler  → encoder-decoder (`ParlerTTSForConditionalGeneration`)
+ *   - OuteTTS → Qwen3-0.6B codec-LM
+ *   - Kani    → conv-backbone codec-LM (`KaniTTS2ForCausalLM`, or the Apache
+ *               default which is a plain `Lfm2ForCausalLM` — hence the repo-name
+ *               gate; the architecture string alone does not identify it).
+ * At `create()` time only the repo is known (the architecture is discovered
+ * during load), so the repo-name signals below cover all three DEFAULT_MODELS
+ * and conventionally-named TTS repos; the architecture arg is honored when a
+ * caller already has it.
+ */
+declare function isTTSRepo(repo?: string, architecture?: string): boolean;
+/** Resolve the model repo for a set of options, falling back to the defaults. */
+declare function resolveDefaultRepo(opts: {
+  repo?: string;
+  embedding?: boolean;
+  enableVision?: boolean;
+}): string;
+//#endregion
+//#region src/gpu/architectures/gemma4_vision.d.ts
+interface Gemma4VisionGraphInfo {
+  hiddenSize: number;
+  numHeads: number;
+  headDim: number;
+  depth: number;
+  intermediateSize: number;
+  textHidden: number;
+  patchSize: number;
+  patchDim: number;
+  poolingKernelSize: number;
+  ropeTheta: number;
+  rmsNormEps: number;
+}
+/**
+ * Resolve the Gemma 4 vision dims from a raw HF config. Accepts either the
+ * top-level config (reads `.vision_config` + `.text_config.hidden_size`) or a
+ * bare vision_config (then `textHidden` falls back to the projector row count if
+ * present, else hidden). Family-general — no E2B constants.
+ */
+declare function resolveGemma4VisionInfo(rawConfig: Record<string, unknown>): Gemma4VisionGraphInfo;
+/**
+ * Dequantize an MLX affine-int4 weight to a plain f32 [rows, cols] matrix.
+ * MLX packs 8 int4 values per u32 (low-nibble first); each group of `groupSize`
+ * columns shares one scale + bias: w[r,c] = scale[r, c/gs] * q + bias[r, c/gs].
+ * Used for the Gemma 4 multimodal projector (`embed_vision.embedding_projection`)
+ * in MLX-4bit checkpoints, where (unlike the BF16 ViT body) the projector is int4.
+ */
+declare function dequantizeMLXProjection(packed: Uint32Array, scales: Float32Array, biases: Float32Array, rows: number, cols: number, groupSize: number): Float32Array;
+/**
+ * If the Gemma 4 multimodal projector arrived as an MLX affine-int4 triplet
+ * (`embed_vision.embedding_projection.{weight(U32), scales, biases}`), dequantize
+ * it in-place to a plain f32 `embed_vision.embedding_projection.weight` and drop
+ * the scales/biases, so the vision graph's plain MatMul on the projector works for
+ * MLX-4bit checkpoints too. No-op for BF16 (HF) checkpoints (weight already f32).
+ */
+declare function dequantizeGemma4VisionProjection(weights: Map<string, {
+  data: ArrayBufferView;
+  shape: number[];
+}>, groupSize: number, rows: number, cols: number): void;
+/**
+ * Patch the ClippedMatMul nodes of a Gemma 4 vision graph with the calibrated clip
+ * scalars from the checkpoint (Gemma4ClippableLinear's per-tensor input/output
+ * min/max buffers), then drop those scalar tensors from the weights map so the
+ * vision executor doesn't try to upload them as GPU buffers. Call BEFORE
+ * VisionExecutor.uploadWeights(). Missing scalars default to ±inf (clip = identity),
+ * so a checkpoint without calibration still loads.
+ */
+declare function patchGemma4VisionClips(graph: ModelGraph, weights: Map<string, {
+  data: ArrayBufferView;
+  shape: number[];
+}>): void;
+/**
+ * Build the Gemma 4 ViT graph. Shaped by symbolic "N" (number of patches, runtime)
+ * and "Np" (number of pooled tokens = ceil(grid_h/k)·ceil(grid_w/k), runtime),
+ * resolved from input tensor dims — like the Qwen ViT's "N"/"Nm".
+ */
+declare function generateGemma4VisionGraph(rawConfig: Record<string, unknown>): ModelGraph;
+//#endregion
+//#region src/gpu/architectures/kani_tts.d.ts
+/** Parsed KaniTTS2 backbone config (the LFM2 dims + the TTS-specific fields). */
+interface KaniConfig {
+  textVocabSize: number;
+  vocabSize: number;
+  tokensPerFrame: number;
+  audioStep: number;
+  useLearnableRope: boolean;
+  alphaMin: number;
+  alphaMax: number;
+  speakerEmbDim: number;
+  audioTokensStart: number;
+  startOfSpeech: number;
+  endOfSpeech: number;
+  codebookSize: number;
   /**
-   * Fuse [per-head q_norm RMSNorm, k_norm RMSNorm, in-place RoPE] into ONE
-   * DualRMSNormRoPE dispatch. Numerically identical (norm then rotate, same
-   * math); requires head_dim <= 256 and RoPE operating in-place on exactly the
-   * two norm outputs. Saves 2 dispatches per full-attention layer — a mobile
-   * (WebKit submit-per-dispatch) win, desktop-neutral.
+   * Whether the backbone uses KaniTTS2's frame-level position IDs (the 4 audio
+   * tokens of a frame share one logical position) + learnable per-layer RoPE.
+   * The `KaniTTS2ForCausalLM` checkpoints (e.g. kani-tts-2-en) do; the plain
+   * `Lfm2ForCausalLM` family (e.g. the Apache kani-tts-450m-0.2-ft / kani-tts-370m)
+   * does NOT — those run standard sequential positions with α=1 plain RoPE.
+   * Detected from the presence of `use_learnable_rope`/`tokens_per_frame`/the
+   * `KaniTTS2ForCausalLM` architecture marker in config.json.
    */
+  frameLevelPositions: boolean;
+}
+declare function parseKaniConfig(rawConfig: Record<string, unknown>): KaniConfig;
+/**
+ * Convert the model's flat audio-token stream (the IDs between start/end-of-speech)
+ * into NanoCodec codes [NUM_GROUPS, T]. Mirrors NemoAudioPlayer.get_nano_codes:
+ *   reshape [-1, 4]; codes[:,c] -= codebook_size*c; codes -= audio_tokens_start;
+ *   transpose → [4, T]. Returns a Uint32Array laid out group-major ([g*T + t]).
+ */
+declare function audioTokensToCodes(audioTokenIds: number[], cfg?: KaniConfig): {
+  codes: Uint32Array;
+  numFrames: number;
+};
+interface NanoCodecGraphOptions {
+  /** Number of audio frames T (the code grid width). PCM length = T * 1764. */
+  numFrames: number;
+}
+declare function generateNanoCodecDecoderGraph(opts: NanoCodecGraphOptions): ModelGraph;
+/**
+ * Generate the KaniTTS codec-LM backbone graph (LFM2-350M body, full-vocab logits,
+ * per-layer learnable MRoPE). Mirrors generateLfm2Graph block-for-block; the only
+ * difference is that each attention layer rotates Q/K with the MRoPE op fed a
+ * per-layer host cos/sin table instead of the position-counter RoPE op.
+ *
+ * dtype:
+ *   • undefined / "f32" — full precision (the checkpoint is bf16/f32 → f32).
+ *   • "q4" — weight-only group-wise INT4 (W4A16) for the LFM2 linear projections
+ *     (q/k/v/o, gate/up/down, short-conv in/out_proj) via MatMulInt4. The tied
+ *     embedding + LM head stay at f32 on purpose: decoder-LM heads are the most
+ *     quantization-sensitive part of a codec-LM and the embed table is the single
+ *     buffer shared by both, so quantizing it would degrade audio quality for no
+ *     load-size win that the int4 projections do not already capture. Backbone
+ *     drops from ~1.5 GB (f32) to ~0.37 GB. The NanoCodec decoder is a separate
+ *     graph and always runs f32.
+ */
+declare function generateKaniTtsGraph(rawConfig: Record<string, unknown>, dtype?: GraphDType, groupSize?: number, kvDtype?: KVDType): ModelGraph;
+//#endregion
+//#region src/gpu/architectures/moonshine.d.ts
+/**
+ * Historical record of the executor-side work the keystone left open; all items
+ * are now implemented (see the STATUS note above). Retained as exported
+ * documentation of the dependency surface.
+ */
+declare const MOONSHINE_REMAINING_WORK: readonly ["DONE: Transpose op kernel (conv output [C,L] → encoder input [L,C]).", "DONE: GroupNorm(num_groups=1) over conv channels (weight+bias).", "DONE: Tanh elementwise op (conv1 activation).", "DONE: Interleaved-RoPE variant (Moonshine rotates adjacent dim pairs 2p/2p+1).", "DONE: No-bias LayerNorm variant (Moonshine norms are weight-only).", "DONE: Per-utterance conv graph regeneration from the concrete sample count.", "DONE: Dual-graph executor — encoder once → frozen cross-attn K/V → AR decode.", "DONE: engine.transcribe(pcm) host path (MoonshineSTT): conv → encode → AR decode → detokenize."];
+interface MoonshineDims {
+  hidden_size: number;
+  enc_layers: number;
+  dec_layers: number;
+  num_heads: number;
+  num_kv_heads: number;
+  head_dim: number;
+  rotary_dim: number;
+  intermediate_size: number;
+  vocab_size: number;
+  rope_base: number;
+  context_length: number;
+  ln_eps: number;
+}
+/** Pull and derive Moonshine dimensions from the raw HF config. */
+declare function parseMoonshineConfig(raw: Record<string, unknown>): MoonshineDims;
+/** Number of encoder frames produced by the conv frontend for n_samples PCM. */
+declare function moonshineEncoderFrames(nSamples: number): number;
+/**
+ * Encoder graph: raw-waveform conv frontend + bidirectional transformer.
+ * @param nSamples concrete PCM sample count (the conv frontend is length-static).
+ * The output tensor "encoder_out" is [T_frames, hidden] and is consumed (after
+ * per-layer K/V projection) as the frozen K/V for the decoder's cross-attention.
+ */
+declare function generateMoonshineEncoderGraph(raw: Record<string, unknown>, nSamples: number): ModelGraph;
+/**
+ * Decoder graph: AR transformer with causal self-attn (KV-cache) + cross-attn to
+ * the frozen encoder output. Built for a single decode step (T=1). The encoder K/V
+ * are supplied as graph inputs "enc_k_layer{i}" / "enc_v_layer{i}" — the host
+ * pre-projects the encoder output through each layer's encoder_attn.k_proj/v_proj
+ * ONCE and binds them frozen for the whole decode (the CrossAttention contract).
+ */
+declare function generateMoonshineDecoderGraph(raw: Record<string, unknown>, sEnc: number): ModelGraph;
+//#endregion
+//#region src/gpu/architectures/outetts.d.ts
+/** Parsed OuteTTS backbone config (the Qwen3 dims). Reuses the generic Qwen path. */
+interface OuteTtsConfig {
+  hidden_size: number;
+  num_layers: number;
+  num_heads: number;
+  num_kv_heads: number;
+  head_dim: number;
+  intermediate_size: number;
+  vocab_size: number;
+  rope_base: number;
+  rms_norm_eps: number;
+  max_position_embeddings: number;
+}
+declare function parseOuteTtsConfig(rawConfig: Record<string, unknown>): OuteTtsConfig;
+/**
+ * Convert the flat generated token stream (the run BETWEEN <|audio_start|> and
+ * <|audio_end|>) into a DAC code grid [NUM_CODEBOOKS, T] (codebook-major [c*T + t]).
+ *
+ * Mirrors outetts v3 `extract_audio_from_tokens`: filter the stream into two ordered
+ * lists by membership of the c1 / c2 ranges, recover the raw code
+ * (id − base), drop the reserved index 1024, and truncate to the shorter list. The
+ * model emits c1,c2 interleaved per frame, but the parse is membership-based (it does
+ * not assume strict pairing) so a stray token cannot desync the grid.
+ */
+declare function audioTokensToDacCodes(tokenIds: number[]): {
+  codes: Uint32Array;
+  numFrames: number;
+};
+interface DacSpeechGraphOptions {
+  /** Number of audio frames T (the code-grid width). */
+  numFrames: number;
   /**
-   * Fuse [Add → RMSNorm] into a single ResidualRMSNorm dispatch: the add's sum
-   * is still materialized (sum_output — downstream residual chain reads it) and
-   * the norm result is written in the same dispatch. Numerically identical.
+   * Number of RVQ codebooks. Default 2 (DAC.speech.v1.0). Parler-TTS's
+   * dac_44khz_8kbps uses 9 — the RVQDequant kernel loops over NCB so the only
+   * change is the codebook/out_proj tensor first-dim and the codes grid height.
    */
-  private fuseAddRMSNormDecodeEntries;
-  private fuseDualRMSNormRoPEDecodeEntries;
-  private fuseDualRMSNormDecodeEntries;
+  numCodebooks?: number;
   /**
-   * Gather buffer entries for a bind group, matching the kernel spec's binding layout.
-   * Uses the pre-allocated inputIdsBuffer for the "input_ids" tensor.
+   * Decoder upsampling rates (the DecoderBlock strides). Default [8,5,4,2]
+   * (DAC.speech.v1.0). Parler's dac_44khz uses [8,8,4,2] (hop 512). Channels
+   * still halve per stage from `decoderDim`.
    */
-  private gatherBuffers;
-  /** Lazily allocate a scratch storage buffer at least `minBytes` large. */
-  private getBindingScratchBuffer;
+  decoderRates?: readonly number[];
+  /** First-conv output channels (decoder_dim). Default 1536. */
+  decoderDim?: number;
+  /** Quantizer out_proj output / first-conv input dim (latent_dim). Default 1024. */
+  latentDim?: number;
 }
+declare function generateDacSpeechDecoderGraph(opts: DacSpeechGraphOptions): ModelGraph;
+/**
+ * Final decoded PCM length (samples) for a T-frame code grid, via the DAC stage chain.
+ * `rates` defaults to DAC.speech.v1.0 ([8,5,4,2]); pass [8,8,4,2] for Parler's dac_44khz.
+ */
+declare function dacOutputLength(numFrames: number, rates?: readonly number[]): number;
+declare function generateOuteTtsBackboneGraph(rawConfig: Record<string, unknown>, dtype?: GraphDType, groupSize?: number, kvDtype?: KVDType): ModelGraph;
+//#endregion
+//#region src/gpu/architectures/qwen3_5_vision.d.ts
+/**
+ * Build the ViT graph. The graph is shaped by symbolic "N" (number of patches),
+ * resolved at run time from the input tensor's first dim — exactly like the LM's
+ * symbolic "T".
+ */
+declare function generateQwen3_5VisionGraph(rawConfig: Record<string, unknown>): ModelGraph;
 //#endregion
 //#region src/gpu/moonshine-executor.d.ts
 interface EncoderResult {
@@ -2252,6 +2815,16 @@ interface GenerateResult {
   totalTime: number;
   /** Why generation stopped. */
   finishReason: "eos" | "max_tokens" | "stop_sequence";
+  /**
+   * Decode-only wall time in ms (excludes prefill). Set by the batched path
+   * (generateBatch) so aggregate decode throughput is measurable directly.
+   */
+  decodeTime?: number;
+  /**
+   * Raw generated token ids, in order. Used by parity harnesses (e.g. the
+   * paged-KV token-exactness gate) to compare runs without decode ambiguity.
+   */
+  tokenIds?: number[];
   /** Thinking content if model produced it (future). */
   thinking?: string;
 }
@@ -2364,8 +2937,12 @@ declare class WebGPUEngine {
   private _outeVoice;
   /** Source of the runtime LoRA adapter currently applied on the static base, if any. */
   private _currentAdapter;
+  /** Named adapters registered for per-lane batched decode (GERBIL_BATCH_LORA). */
+  private _batchAdapters;
   /** Lazily-created Parler-TTS engine (Flan-T5 encoder + decoder LM + dac_44khz). */
   private _parlerTTS;
+  /** Lazily-created continuous-batching scheduler (GERBIL_BATCH, Phase 5). */
+  private _scheduler;
   /**
    * 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
@@ -2423,6 +3000,17 @@ declare class WebGPUEngine {
   loadAdapter(source: string | null): Promise<void>;
   /** The runtime LoRA adapter currently applied on the base, or null. */
   getAdapter(): string | null;
+  /**
+   * 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.
+   */
+  registerAdapter(name: string, source: string): Promise<void>;
+  /** Names of the adapters registered for per-lane batched decode. */
+  getRegisteredAdapters(): string[];
   /**
    * Write a coarse crash-phase breadcrumb that survives a GPU-process kill / page
    * reload. The iPad harness reads `localStorage["gerbil-crash-phase"]` after a
@@ -2501,6 +3089,66 @@ declare class WebGPUEngine {
    * the same instance awaits this one (see {@link _genQueueTail}).
    */
   generate(prompt: string | ChatMessage[], options?: GenerateOptions): Promise<GenerateResult>;
+  /**
+   * 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).
+   */
+  generateBatch(prompts: Array<string | ChatMessage[]>, options?: GenerateOptions & {
+    maxTokensPerRow?: number[];
+    /**
+     * Per-lane adapter names (SGMV phase 1 — requires GERBIL_BATCH_LORA=1
+     * and prior {@link registerAdapter} calls). `adapters[i]` selects the
+     * adapter lane i decodes with; null/undefined = bare base. Lanes with
+     * different adapters (or none) decode concurrently over the shared base.
+     */
+    adapters?: Array<string | null | undefined>;
+  }): Promise<GenerateResult[]>;
+  /**
+   * 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(): RequestScheduler;
+  /**
+   * 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.
+   */
+  createSwarm<R = Record<string, ServeResult>>(options: SwarmOptions<R>): Promise<Swarm<R>>;
+  /**
+   * 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
+   * token (`<turn|>`, id 106) rather than the generic `<eos>`. Every text-decode
+   * loop must treat it as a stop token or the model runs on past its answer and
+   * repeats until it hits `maxTokens`. Resolved from the tokenizer's added tokens
+   * so it is null for models without a turn delimiter (Qwen, LFM2, …), leaving
+   * their decode behaviour unchanged.
+   */
+  private resolveEndOfTurnId;
   private _generateLocked;
   /**
    * Inline autocomplete: continue `prefix` with a brief, single-line continuation.
@@ -2834,5 +3482,5 @@ declare class WebGPUEngine {
   private _acquireGenLock;
 }
 //#endregion
-export { GEMMA4_IMAGE_PROCESSOR as $, generateDacSpeechDecoderGraph as A, AdapterConfig as At, generateNanoCodecDecoderGraph as B, SpeakOptions as Bt, TranscribeOptions as C, LoadedMoonshine as Ct, generateQwen3_5VisionGraph as D, quantizeKaniBackbone as Dt, Executor as E, loadMoonshine as Et, generateMoonshineEncoderGraph as F, fetchAdapter as Ft, generateGemma4VisionGraph as G, KVDType as Gt, Gemma4VisionGraphInfo as H, GPUDiagnosticResult as Ht, moonshineEncoderFrames as I, splitFusedQGateDelta as It, DEFAULT_MODELS as J, ModelCapabilities as Jt, patchGemma4VisionClips as K, KvMode as Kt, parseMoonshineConfig as L, KaniDType as Lt, parseOuteTtsConfig as M, LoRADelta as Mt, MOONSHINE_REMAINING_WORK as N, applyLoRAToStore as Nt, audioTokensToDacCodes as O, ChatMessage as Ot, generateMoonshineDecoderGraph as P, buildLoRADeltas as Pt, resolveDefaultRepo as Q, audioTokensToCodes as R, KaniTTS as Rt, MoonshineSTTOptions as S, LoadedKaniTTS as St, MoonshineEncoderExecutor as T, loadModel as Tt, dequantizeGemma4VisionProjection as U, initGPU as Ut, parseKaniConfig as V, SpeakResult as Vt, dequantizeMLXProjection as W, GraphDType as Wt, OUTETTS_PRESET_VOICES as X, OUTETTS_ASSETS as Y, createDefaultHFKeyMapper as Yt, isTTSRepo as Z, ParlerSpeakOptions as _, mropeFreqDims as _t, GenerateObjectOptions as a, VisionGridConfig as at, ParlerTTSOptions as b, smartResize as bt, GenerateResult as c, buildGemma4PosEmbeds as ct, ObjectSchema as d, buildMRoPECosSin as dt, Gemma4VisionGridConfig as et, ObjectValidator as f, buildMRoPEPositionIds as ft, VisionInputs as g, buildVisionPositionTensors as gt, VisionExecutor as h, buildRotaryCosSin as ht, EncodeImageResult as i, QWEN3_5_IMAGE_PROCESSOR as it, generateOuteTtsBackboneGraph as j, AdapterSource as jt, dacOutputLength as k, Tokenizer as kt, IntegrityCheckEntry as l, buildGemma4RotaryCosSin as lt, WebGPUEngineOptions as m, buildPositionIds as mt, AgentTool as n, ImageProcessorConfig as nt, GenerateObjectResult as o, VisionPositionTensors as ot, WebGPUEngine as p, buildPosEmbeds as pt, resolveGemma4VisionInfo as q, ModelArchConfig as qt, EmbedOptions as r, PreprocessedImage as rt, GenerateOptions as s, buildGemma4PoolMatrix as st, AgentStep as t, Gemma4VisionPositionTensors as tt, IntegrityCheckResult as u, buildGemma4VisionPositionTensors as ut, ParlerSpeakResult as v, preprocessImage as vt, TranscribeResult as w, loadKaniTTS as wt, MoonshineSTT as x, SamplingParams as xt, ParlerTTS as y, preprocessImageGemma4 as yt, generateKaniTtsGraph as z, KaniTTSOptions as zt };
-//# sourceMappingURL=index-DeKYzJgJ.d.mts.map
+export { Gemma4VisionGridConfig as $, GraphDType as $t, generateOuteTtsBackboneGraph as A, Executor as At, parseKaniConfig as B, AdapterSource as Bt, TranscribeOptions as C, SwarmOptions as Ct, audioTokensToDacCodes as D, SchedulerStats as Dt, generateQwen3_5VisionGraph as E, RequestScheduler as Et, moonshineEncoderFrames as F, loadMoonshine as Ft, patchGemma4VisionClips as G, splitFusedQGateDelta as Gt, dequantizeGemma4VisionProjection as H, applyLoRAToStore as Ht, parseMoonshineConfig as I, quantizeKaniBackbone as It, OUTETTS_ASSETS as J, KaniTTSOptions as Jt, resolveGemma4VisionInfo as K, KaniDType as Kt, audioTokensToCodes as L, ChatMessage as Lt, MOONSHINE_REMAINING_WORK as M, LoadedMoonshine as Mt, generateMoonshineDecoderGraph as N, loadKaniTTS as Nt, dacOutputLength as O, ServeOptions as Ot, generateMoonshineEncoderGraph as P, loadModel as Pt, GEMMA4_IMAGE_PROCESSOR as Q, initGPU as Qt, generateKaniTtsGraph as R, Tokenizer as Rt, MoonshineSTTOptions as S, SwarmMemberResult as St, MoonshineEncoderExecutor as T, SwarmTaskOptions as Tt, dequantizeMLXProjection as U, buildLoRADeltas as Ut, Gemma4VisionGraphInfo as V, LoRADelta as Vt, generateGemma4VisionGraph as W, fetchAdapter as Wt, isTTSRepo as X, SpeakResult as Xt, OUTETTS_PRESET_VOICES as Y, SpeakOptions as Yt, resolveDefaultRepo as Z, GPUDiagnosticResult as Zt, ParlerSpeakOptions as _, preprocessImage as _t, GenerateObjectOptions as a, VisionPositionTensors as at, ParlerTTSOptions as b, SamplingParams as bt, GenerateResult as c, buildGemma4RotaryCosSin as ct, ObjectSchema as d, buildMRoPEPositionIds as dt, KVDType as en, Gemma4VisionPositionTensors as et, ObjectValidator as f, buildPosEmbeds as ft, VisionInputs as g, mropeFreqDims as gt, VisionExecutor as h, buildVisionPositionTensors as ht, EncodeImageResult as i, createDefaultHFKeyMapper as in, VisionGridConfig as it, parseOuteTtsConfig as j, LoadedKaniTTS as jt, generateDacSpeechDecoderGraph as k, ServeResult as kt, IntegrityCheckEntry as l, buildGemma4VisionPositionTensors as lt, WebGPUEngineOptions as m, buildRotaryCosSin as mt, AgentTool as n, ModelArchConfig as nn, PreprocessedImage as nt, GenerateObjectResult as o, buildGemma4PoolMatrix as ot, WebGPUEngine as p, buildPositionIds as pt, DEFAULT_MODELS as q, KaniTTS as qt, EmbedOptions as r, ModelCapabilities as rn, QWEN3_5_IMAGE_PROCESSOR as rt, GenerateOptions as s, buildGemma4PosEmbeds as st, AgentStep as t, KvMode as tn, ImageProcessorConfig as tt, IntegrityCheckResult as u, buildMRoPECosSin as ut, ParlerSpeakResult as v, preprocessImageGemma4 as vt, TranscribeResult as w, SwarmTask as wt, MoonshineSTT as x, Swarm as xt, ParlerTTS as y, smartResize as yt, generateNanoCodecDecoderGraph as z, AdapterConfig as zt };
+//# sourceMappingURL=index-CNYoTRgr.d.mts.map