W4A16 double-GEMV (M=2): reads weights once, computes 2 outputs. A: [2, K] BF16 contiguous, B: NVFP4 packed, C: [2, N] BF16 contiguous. Same weight b

Serialise an `LqerCorrection` to the `.lqer` on-disk format. Used by the offline calibration tool and round-trip tests.

Compute the YaRN `_mscale` ratio that DeepSeek folds into the rope cos/sin: `get_mscale(factor, mscale) / get_mscale(factor, mscale_all_dim)`. Returns

Zero all reusable buffers to eliminate stale data between requests. Ensures deterministic computation regardless of request history.

Splice `other` into `self`, offsetting all of `other`'s state ids. Returns the state mapping `other_id -> new_id`.

Add a raw typed edge (`type` is one of [`edge_type`], `value` goes into `max`).

Issue #31: after a successful slide advances `window_start` to `new_window_start`, advance every attention layer's offload cursor to keep pace. Layers

Allocate a unique rule name based on `hint`, returning the name actually assigned. Port of `AllocateRuleName`.

Legacy apply_chat_template for callers that pass (role, content) tuples. Converts to JSON messages and delegates to apply_chat_template_jinja.

Reserve a slot for `key`. If the pool is full, picks an evictable slot from `evict_candidates` (callers pass them in score-ascending order; the lowest

Begin capturing CUDA operations on `stream` into a graph. All kernel launches and async copies on this stream between `begin_capture` and `end_captur

Convert BF16 activations to FP8 E4M3 for FP8×FP8 GEMM. Grid: (ceil(total_elements/2 / 256), 1, 1) Block: (256, 1, 1)

Bytes per block (K or V, not both) for a specific dtype and (num_kv_heads, head_dim) pair. Per-layer callers pass their layer's actual dimensions; hom

Build a device-side pointer table from pre-transposed QuantizedWeight vec.

Bump the per-response tool-call counter and trip `stop_string_triggered` when the cap is exceeded. Catches pathological responses emitting dozens of t

Encode a codepoint into UTF-8 bytes. Faithful to C++ `CharToUTF8`: it does not validate surrogates and produces 1–4 bytes for codepoints in `0..=0x10

Check whether `sentence` is a near-duplicate of any sentence already in the ring. Returns `true` on duplicate. Always pushes the new bigram-set into t

Detect a repeating line or long phrase in the post-detector content buffer. Returns true when the last non-trivial line occurs (fuzzy-matched on colla

Compile a grammar that enforces a JSON schema.

Build and compile a structural tag grammar from raw JSON components. This bypasses xgrammar-rs's `compile_structural_tag` wrapper to access `at_least_

Compute a session hash from tokenized prompt. Hashes up to 1024 tokens — covers the full system prompt + first user message for most clients (Claude C

Whether `element` is present.

Create a new swap file. Returns `(id, buffered_writer)`.

Number of decode-rollback SSM snapshot slots reserved **per active sequence** (Phase-C). The scheduler's per-sequence snapshot ring is sized from this

Decoded token bytes, indexed by token id (length `vocab_size`).

Dense FP8-weight GEMV (M=1): C = A @ (dequant(B_fp8) * row_scale). A: `[1, K]` BF16, B: `[N, K]` FP8 E4M3, row_scale: `[N]` f32, C: `[1, N]` BF16. Ha

Dequantize FP8 E4M3 → BF16, writing into a pre-allocated destination buffer. Avoids gpu.alloc/free for the intermediate BF16 data. The caller provide

Feed `text` to the detector in `chunk`-byte slices (ASCII fixtures), then flush — exercises cross-chunk tag reassembly like the live token stream.

End capture and return an instantiated graph ready for replay.

Phase 6.3 — Sliding-window allocation helper (prefill path). Same as `ensure_blocks_through_decode` but with a prefix-cache eviction fallback: if `kv

Compute the epsilon closure of `state_set` in place over `edges`. The set is *not* cleared — every state already present plus every state reachable f

Escape the regex-significant `.` in a formatted-float boundary string so it is treated as a literal decimal point rather than the wildcard. Port of `E

Send final response and free GPU resources for a completed sequence.

Flatten Anthropic message content blocks into a single text string. For assistant messages with tool_use blocks, also extracts tool calls so they can

Flush anything held in the streaming sanitizer's tail buffer at stream end. Drops content if tag-suppression is still active (no close arrived) or if

Gated RMS norm (norm_before_gate=False, per-group): output = rms_norm_per_group(input * silu(gate), weight, group_size) Kernel: `gated_rms_norm(input

Dispatch to the per-kind generator. Port of `GenerateFromSpec`.

Fetch a snapshot of the conversation. TTL-expired entries are evicted and return None.

(kind, idx) trace of the indexed detector events, in emission order. `kind` ∈ {"start", "end", "call"} — fragments/deltas are asserted separately via

Returns a borrowed reference to the underlying HF tokenizer (for callers that need to drive low-level encode/decode directly).

Replace `lhs` with the sorted intersection of `lhs` and `rhs`. Both inputs must already be sorted ascending. As a special case, `lhs == [-1]` is trea

True if no states are pending.

Check whether expert parallelism (EP) is enabled (multi-GPU MoE). When true, the scheduler must use separate decode + prefill commands with explicit

Check if a specific token is allowed by the current bitmask.

LM head for K tokens: hidden[K, H] → logits[K, V].

Mamba-2 d_inner = mamba_num_heads * mamba_head_dim.

Number of actual matcher history steps (== tokens `rollback` can undo). BUG#3 (2026-06-02): `accept_token` returns `true` for stop/EOS tokens and in

Observe is a no-op for prompt lookup (the history IS the cache).

Parse + normalize + optimize an EBNF grammar — the same pipeline `GrammarCompiler::compile_normalized` runs before compilation.

Parse a single `.lqer` file's bytes into an `LqerCorrection`. Pure / no I/O — exposed for testing the format independently of the filesystem.

Parse MiniMax XML inner content: `<invoke name="NAME"><parameter name="K">V</parameter>...</invoke>`. The outer `<minimax:tool_call>` wrapper is alre

Remove every provably-dead state from `states` in place. A pure optimization: the retained set parses exactly the same language. No-ops when pruning i

Read back first `n` BF16 values from device and return as f32 + L2 norm.

Try to reclaim a snapshot slot by evicting the LRU snapshot from the prefix cache's snapshot index. Snapshots are decoupled from tree nodes, so this d

Convert a regex to an EBNF body, mapping converter errors into a [`SchemaError`]. `with_rule_name = false` matches the C++ `RegexToEBNF(..., false)` c

Clear the per-tool-call incremental-streaming bookkeeping (called after each call closes and on `reset`). Does NOT touch `tools`/`buffer_args`.