webinfer 0.0.3 → 0.0.4

package/dist/kernels/activation.wgsl.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Activation function WGSL kernels
+ */
+export interface ActivationConfig {
+    dtype: 'f32' | 'f16';
+}
+/**
+ * SiLU (Swish) activation: silu(x) = x * sigmoid(x) = x / (1 + exp(-x))
+ */
+export declare function generateSiLUAndMulShader(config: ActivationConfig): string;
+/**
+ * GELU activation: gelu(x) ≈ 0.5 * x * (1 + tanh(sqrt(2/π) * (x + 0.044715 * x^3)))
+ */
+export declare function generateGELUAndMulShader(config: ActivationConfig): string;

package/dist/kernels/batch-decode-paged.wgsl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Batched decode attention with paged KV cache
+ */
+export interface BatchDecodePagedConfig {
+    num_qo_heads: number;
+    num_kv_heads: number;
+    head_dim: number;
+    page_size: number;
+    sm_scale: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateBatchDecodePagedShader(config: BatchDecodePagedConfig): string;

package/dist/kernels/batch-prefill-paged.wgsl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Batched prefill attention with paged KV cache
+ */
+export interface BatchPrefillPagedConfig {
+    num_qo_heads: number;
+    num_kv_heads: number;
+    head_dim: number;
+    page_size: number;
+    sm_scale: number;
+    causal: boolean;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateBatchPrefillPagedShader(config: BatchPrefillPagedConfig): string;

package/dist/kernels/decode-attention.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Single decode attention WGSL kernel
+ *
+ * Flash Attention for decode phase (single token query)
+ * Uses online softmax to avoid materializing full attention matrix
+ */
+export interface DecodeAttentionConfig {
+    num_qo_heads: number;
+    num_kv_heads: number;
+    head_dim: number;
+    seq_len: number;
+    sm_scale: number;
+    dtype: 'f32' | 'f16';
+    useSubgroups: boolean;
+}
+export declare function generateDecodeAttentionShader(config: DecodeAttentionConfig): string;

package/dist/kernels/gemm.wgsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * GEMM (General Matrix Multiplication) kernels
+ */
+export interface GemmConfig {
+    M: number;
+    N: number;
+    K: number;
+    tile_m: number;
+    tile_n: number;
+    tile_k: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateBmmShader(config: GemmConfig): string;
+/**
+ * Simpler non-tiled GEMM for small matrices
+ */
+export declare function generateSimpleBmmShader(dtype: 'f32' | 'f16'): string;

package/dist/kernels/page.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Paged KV cache append kernel
+ */
+export interface PageAppendConfig {
+    page_size: number;
+    num_kv_heads: number;
+    head_dim: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generatePageAppendShader(config: PageAppendConfig): string;

package/dist/kernels/prefill-attention.wgsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Single prefill attention WGSL kernel
+ *
+ * Flash Attention for prefill phase (multiple query tokens)
+ * Uses online softmax and supports causal masking
+ */
+export interface PrefillAttentionConfig {
+    num_qo_heads: number;
+    num_kv_heads: number;
+    head_dim: number;
+    qo_len: number;
+    kv_len: number;
+    sm_scale: number;
+    causal: boolean;
+    dtype: 'f32' | 'f16';
+}
+export declare function generatePrefillAttentionShader(config: PrefillAttentionConfig): string;

package/dist/kernels/rmsnorm.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RMSNorm WGSL kernel template
+ */
+export interface RMSNormConfig {
+    hiddenSize: number;
+    eps: number;
+    dtype: 'f32' | 'f16';
+    useSubgroups: boolean;
+}
+export declare function generateRMSNormShader(config: RMSNormConfig): string;

package/dist/kernels/rope.wgsl.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RoPE (Rotary Position Embedding) kernels
+ */
+export interface RoPEConfig {
+    head_dim: number;
+    rope_scale: number;
+    rope_theta: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateRoPEShader(config: RoPEConfig): string;
+export interface Llama31RoPEConfig {
+    head_dim: number;
+    rope_theta: number;
+    low_freq_factor: number;
+    high_freq_factor: number;
+    old_context_len: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateLlama31RoPEShader(config: Llama31RoPEConfig): string;

package/dist/kernels/sampling.wgsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Sampling kernels for token generation
+ */
+export interface SamplingConfig {
+    vocab_size: number;
+    batch_size: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateCategoricalSamplingShader(config: SamplingConfig): string;
+export interface TopKSamplingConfig {
+    vocab_size: number;
+    batch_size: number;
+    top_k: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateTopKSamplingShader(config: TopKSamplingConfig): string;
+export interface TopPSamplingConfig {
+    vocab_size: number;
+    batch_size: number;
+    top_p: number;
+    dtype: 'f32' | 'f16';
+}
+export declare function generateTopPSamplingShader(config: TopPSamplingConfig): string;

package/dist/norm/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Normalization operations
+ */
+import type { WebInferContext } from '../core/context.ts';
+import type { Tensor } from '../core/tensor.ts';
+/**
+ * Root Mean Square Normalization
+ *
+ * Computes: output = (input / sqrt(mean(input^2) + eps)) * weight
+ *
+ * @param ctx WebInfer context
+ * @param input Input tensor of shape [..., hidden_size]
+ * @param weight Weight tensor of shape [hidden_size]
+ * @param eps Small constant for numerical stability (default: 1e-5)
+ * @returns Normalized tensor of same shape as input
+ */
+export declare function rmsnorm(ctx: WebInferContext, input: Tensor, weight: Tensor, eps?: number): Promise<Tensor>;
+/**
+ * Fused Add + RMSNorm
+ *
+ * Computes: output = rmsnorm(input + residual)
+ * Returns both the normalized output and the new residual (input + residual)
+ *
+ * @param ctx WebInfer context
+ * @param input Input tensor
+ * @param residual Residual tensor to add
+ * @param weight Weight tensor
+ * @param eps Small constant for numerical stability (default: 1e-5)
+ * @returns [output, new_residual] tuple
+ */
+export declare function fused_add_rmsnorm(ctx: WebInferContext, input: Tensor, residual: Tensor, weight: Tensor, eps?: number): Promise<[Tensor, Tensor]>;
+/**
+ * Gemma RMSNorm variant (adds 1.0 to weight)
+ *
+ * Computes: output = (input / sqrt(mean(input^2) + eps)) * (weight + 1.0)
+ *
+ * @param ctx WebInfer context
+ * @param input Input tensor
+ * @param weight Weight tensor
+ * @param eps Small constant for numerical stability (default: 1e-5)
+ * @returns Normalized tensor
+ */
+export declare function gemma_rmsnorm(ctx: WebInferContext, input: Tensor, weight: Tensor, eps?: number): Promise<Tensor>;

package/dist/page/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Paged KV cache operations
+ */
+import type { WebInferContext } from '../core/context.ts';
+import type { Tensor } from '../core/tensor.ts';
+import type { PagedKvCache } from '../core/paged-kv-cache.ts';
+/**
+ * Append new KV pairs to paged KV cache
+ *
+ * Appends new key-value pairs to the paged KV cache structure.
+ * Each batch item gets its new KV appended to its last page.
+ *
+ * @param ctx WebInfer context
+ * @param paged_kv_cache The paged KV cache to append to
+ * @param indptr Indirection pointer array [batch_size + 1]
+ * @param indices Page indices array [nnz_pages]
+ * @param last_page_len Number of valid tokens in last page for each batch item [batch_size]
+ * @param k New keys to append [total_len, num_kv_heads, head_dim]
+ * @param v New values to append [total_len, num_kv_heads, head_dim]
+ */
+export declare function append_paged_kv_cache(ctx: WebInferContext, paged_kv_cache: PagedKvCache, indptr: Tensor, indices: Tensor, last_page_len: Tensor, k: Tensor, v: Tensor): Promise<void>;

package/dist/prefill/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Prefill attention operations
+ */
+import type { WebInferContext } from '../core/context.ts';
+import type { Tensor } from '../core/tensor.ts';
+import type { PagedKvCache } from '../core/paged-kv-cache.ts';
+import { PosEncodingMode } from '../core/types.ts';
+/**
+ * Single prefill with KV cache
+ *
+ * Performs attention for multiple query tokens (prefill phase) with KV cache.
+ * Uses flash attention with online softmax and supports causal masking.
+ *
+ * @param ctx WebInfer context
+ * @param q Query tensor of shape [qo_len, num_qo_heads, head_dim]
+ * @param k Key tensor of shape [kv_len, num_kv_heads, head_dim]
+ * @param v Value tensor of shape [kv_len, num_kv_heads, head_dim]
+ * @param causal Whether to apply causal masking (default: true)
+ * @param pos_encoding_mode Position encoding mode (default: NONE)
+ * @param sm_scale Softmax scale (default: 1/sqrt(head_dim))
+ * @param rope_scale RoPE scale (default: 1.0) - not yet implemented
+ * @param rope_theta RoPE theta (default: 10000.0) - not yet implemented
+ * @returns Output tensor of shape [qo_len, num_qo_heads, head_dim]
+ */
+export declare function single_prefill_with_kv_cache(ctx: WebInferContext, q: Tensor, k: Tensor, v: Tensor, causal?: boolean, pos_encoding_mode?: PosEncodingMode, sm_scale?: number, rope_scale?: number, rope_theta?: number): Promise<Tensor>;
+/**
+ * Batched prefill with paged KV cache wrapper
+ *
+ * FlashInfer-compatible wrapper for batched prefill attention with paged KV cache.
+ */
+export declare class BatchPrefillWithPagedKVCacheWrapper {
+    private ctx;
+    private planned;
+    private num_qo_heads;
+    private num_kv_heads;
+    private head_dim;
+    private page_size;
+    private sm_scale;
+    private causal;
+    private pos_encoding_mode;
+    constructor(ctx: WebInferContext);
+    /**
+     * Plan the batched prefill operation
+     *
+     * @param qo_indptr Query indirection pointer [batch_size + 1]
+     * @param paged_kv_indptr Paged KV indirection pointer [batch_size + 1]
+     * @param paged_kv_indices Paged KV indices [nnz_pages]
+     * @param paged_kv_last_page_len Last page lengths [batch_size]
+     * @param num_qo_heads Number of query heads
+     * @param num_kv_heads Number of KV heads
+     * @param head_dim Head dimension
+     * @param page_size Page size
+     * @param causal Whether to apply causal masking (default: true)
+     * @param pos_encoding_mode Position encoding mode (default: NONE)
+     */
+    plan(qo_indptr: Tensor, paged_kv_indptr: Tensor, paged_kv_indices: Tensor, paged_kv_last_page_len: Tensor, num_qo_heads: number, num_kv_heads: number, head_dim: number, page_size: number, causal?: boolean, pos_encoding_mode?: PosEncodingMode): void;
+    /**
+     * Run the batched prefill operation
+     *
+     * @param q Query tensor [total_qo_len, num_qo_heads, head_dim]
+     * @param paged_kv_cache Paged KV cache
+     * @param qo_indptr Query indirection pointer [batch_size + 1]
+     * @param paged_kv_indptr Paged KV indirection pointer [batch_size + 1]
+     * @param paged_kv_indices Paged KV indices [nnz_pages]
+     * @param paged_kv_last_page_len Last page lengths [batch_size]
+     * @returns Output tensor [total_qo_len, num_qo_heads, head_dim]
+     */
+    run(q: Tensor, paged_kv_cache: PagedKvCache, qo_indptr: Tensor, paged_kv_indptr: Tensor, paged_kv_indices: Tensor, paged_kv_last_page_len: Tensor): Promise<Tensor>;
+}

package/dist/rope/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * RoPE (Rotary Position Embedding) operations
+ */
+import type { WebInferContext } from '../core/context.ts';
+import type { Tensor } from '../core/tensor.ts';
+/**
+ * Apply RoPE (Rotary Position Embedding) in-place
+ *
+ * Applies rotary position embeddings to query and key tensors.
+ * Modifies tensors in-place.
+ *
+ * @param ctx WebInfer context
+ * @param q Query tensor [nnz, num_qo_heads, head_dim]
+ * @param k Key tensor [nnz, num_kv_heads, head_dim]
+ * @param indptr Indirection pointer [batch_size + 1]
+ * @param offsets Position offsets for each batch item [batch_size]
+ * @param rope_scale RoPE scale factor (default: 1.0)
+ * @param rope_theta RoPE theta base (default: 10000.0)
+ */
+export declare function apply_rope_inplace(ctx: WebInferContext, q: Tensor, k: Tensor, indptr: Tensor, offsets: Tensor, rope_scale?: number, rope_theta?: number): Promise<void>;
+/**
+ * Apply Llama 3.1 RoPE variant in-place
+ *
+ * Applies Llama 3.1's frequency-scaled RoPE for long context support.
+ * Modifies tensors in-place.
+ *
+ * @param ctx WebInfer context
+ * @param q Query tensor [nnz, num_qo_heads, head_dim]
+ * @param k Key tensor [nnz, num_kv_heads, head_dim]
+ * @param indptr Indirection pointer [batch_size + 1]
+ * @param offsets Position offsets [batch_size]
+ * @param low_freq_factor Low frequency scaling factor (default: 1.0)
+ * @param high_freq_factor High frequency scaling factor (default: 4.0)
+ * @param old_context_len Original context length before scaling (default: 8192)
+ * @param rope_theta RoPE theta base (default: 500000.0)
+ */
+export declare function apply_llama31_rope_inplace(ctx: WebInferContext, q: Tensor, k: Tensor, indptr: Tensor, offsets: Tensor, low_freq_factor?: number, high_freq_factor?: number, old_context_len?: number, rope_theta?: number): Promise<void>;

package/dist/sampling/index.d.ts

@@ -1,6 +1,55 @@
 /**
- * Sampling Module Exports
+ * Sampling operations for token generation
  */
-export { topK, topKFilter } from "./top-k.ts";
-export { topPFilter } from "./top-p.ts";
-export { sample, sampleGreedy, sampleFromProbs, softmax, applyRepetitionPenalty, minPSamplingFromProbs, topKSamplingFromProbs, topPSamplingFromProbs, topKTopPSamplingFromProbs, topKTopPSamplingFromLogits, topPRenormProbs, topKRenormProbs, topKMaskLogits, type SamplingConfig, } from "./sampler.ts";
+import type { WebInferContext } from '../core/context.ts';
+import { Tensor } from '../core/tensor.ts';
+/**
+ * Sample from probability distribution (categorical sampling)
+ *
+ * @param ctx WebInfer context
+ * @param probs Probability tensor [batch_size, vocab_size]
+ * @param uniform_samples Uniform random samples [batch_size] in range [0, 1)
+ * @returns Sampled token IDs [batch_size]
+ */
+export declare function sampling_from_probs(ctx: WebInferContext, probs: Tensor, uniform_samples: Tensor): Promise<Tensor>;
+/**
+ * Top-k sampling from probability distribution
+ *
+ * @param ctx WebInfer context
+ * @param probs Probability tensor [batch_size, vocab_size]
+ * @param uniform_samples Uniform random samples [batch_size]
+ * @param top_k Number of top candidates to consider
+ * @returns Sampled token IDs [batch_size]
+ */
+export declare function top_k_sampling_from_probs(ctx: WebInferContext, probs: Tensor, uniform_samples: Tensor, top_k: number): Promise<Tensor>;
+/**
+ * Top-p (nucleus) sampling from probability distribution
+ *
+ * @param ctx WebInfer context
+ * @param probs Probability tensor [batch_size, vocab_size]
+ * @param uniform_samples Uniform random samples [batch_size]
+ * @param top_p Cumulative probability threshold (0, 1]
+ * @returns Sampled token IDs [batch_size]
+ */
+export declare function top_p_sampling_from_probs(ctx: WebInferContext, probs: Tensor, uniform_samples: Tensor, top_p: number): Promise<Tensor>;
+/**
+ * Min-p sampling from probability distribution
+ *
+ * @param ctx WebInfer context
+ * @param probs Probability tensor [batch_size, vocab_size]
+ * @param uniform_samples Uniform random samples [batch_size]
+ * @param min_p Minimum probability threshold relative to max prob
+ * @returns Sampled token IDs [batch_size]
+ */
+export declare function min_p_sampling_from_probs(ctx: WebInferContext, probs: Tensor, uniform_samples: Tensor, min_p: number): Promise<Tensor>;
+/**
+ * Combined top-k and top-p sampling
+ *
+ * @param ctx WebInfer context
+ * @param probs Probability tensor [batch_size, vocab_size]
+ * @param uniform_samples Uniform random samples [batch_size]
+ * @param top_k Number of top candidates
+ * @param top_p Cumulative probability threshold
+ * @returns Sampled token IDs [batch_size]
+ */
+export declare function top_k_top_p_sampling_from_probs(ctx: WebInferContext, probs: Tensor, uniform_samples: Tensor, top_k: number, top_p: number): Promise<Tensor>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webinfer",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "High-performance LLM inference kernels for WebGPU",
   "license": "Apache-2.0",
   "repository": {

package/dist/attention/block-sparse/format.d.ts

@@ -1,52 +0,0 @@
-/**
- * Block-Sparse CSR Format
- * Enables a single kernel to support all attention variants
- */
-/**
- * Block-Sparse CSR representation of attention mask
- */
-export interface BlockSparseCSR {
-    blockSize: number;
-    rowPtr: Uint32Array;
-    colIdx: Uint32Array;
-    blockMask?: Uint8Array;
-    numRows: number;
-    numCols: number;
-    numBlockRows: number;
-    numBlockCols: number;
-    nnzBlocks: number;
-}
-/**
- * Attention pattern types
- */
-export type AttentionPattern = {
-    type: "dense";
-} | {
-    type: "causal";
-} | {
-    type: "sliding";
-    windowSize: number;
-} | {
-    type: "global-local";
-    globalTokens: number[];
-    localWindow: number;
-} | {
-    type: "custom";
-    mask: boolean[][];
-};
-/**
- * Build BS-CSR from attention pattern
- */
-export declare function buildBlockSparseCSR(seqLen: number, pattern: AttentionPattern, blockSize?: number): BlockSparseCSR;
-/**
- * Calculate sparsity ratio of the mask
- */
-export declare function getSparsityRatio(csr: BlockSparseCSR): number;
-/**
- * Estimate memory savings from sparsity
- */
-export declare function estimateMemorySavings(csr: BlockSparseCSR): {
-    denseBytes: number;
-    sparseBytes: number;
-    savingsRatio: number;
-};

package/dist/attention/block-sparse/patterns/causal.d.ts

@@ -1,16 +0,0 @@
-/**
- * Causal (autoregressive) attention pattern
- * Used in GPT, Llama, and most decoder-only models
- */
-import { type BlockSparseCSR } from "../format.ts";
-/**
- * Build causal attention mask in BS-CSR format
- * Each query position can only attend to positions <= its own position
- */
-export declare function buildCausalMask(seqLen: number, blockSize?: number): BlockSparseCSR;
-/**
- * Get the theoretical sparsity of causal attention
- * For a sequence of length N, causal attention has N*(N+1)/2 non-zero elements
- * out of N*N total, giving ~50% sparsity for large N
- */
-export declare function getCausalSparsity(seqLen: number): number;

package/dist/attention/block-sparse/patterns/sliding.d.ts

@@ -1,22 +0,0 @@
-/**
- * Sliding window attention pattern
- * Used in Mistral and other efficient attention models
- */
-import { type BlockSparseCSR } from "../format.ts";
-/**
- * Build sliding window attention mask in BS-CSR format
- * Each query can only attend to the previous `windowSize` positions
- */
-export declare function buildSlidingWindowMask(seqLen: number, windowSize: number, blockSize?: number): BlockSparseCSR;
-/**
- * Get the theoretical sparsity of sliding window attention
- * For window size W and sequence length N:
- * - First W positions have triangular attention (like causal)
- * - Remaining N-W positions have W+1 attention each
- */
-export declare function getSlidingWindowSparsity(seqLen: number, windowSize: number): number;
-/**
- * Sliding window with causal constraint
- * This is what Mistral uses - combines sliding window with causal masking
- */
-export declare function buildCausalSlidingWindowMask(seqLen: number, windowSize: number, blockSize?: number): BlockSparseCSR;

package/dist/attention/block-sparse/patterns/tree.d.ts

@@ -1,65 +0,0 @@
-/**
- * Tree Attention Pattern
- * Used in speculative decoding (Medusa, EAGLE) and tree-based generation
- */
-import { type BlockSparseCSR } from "../format.ts";
-/**
- * Tree node structure
- */
-export interface TreeNode {
-    /** Token position in sequence */
-    position: number;
-    /** Parent position (-1 for root) */
-    parent: number;
-    /** Depth in tree (0 for root) */
-    depth: number;
-}
-/**
- * Tree attention configuration
- */
-export interface TreeAttentionConfig {
-    /** Total sequence length including prompt */
-    seqLen: number;
-    /** Prompt length (prefix that all tokens attend to) */
-    promptLen: number;
-    /** Tree structure for speculative tokens */
-    tree: TreeNode[];
-    /** Block size for sparse format */
-    blockSize?: number;
-}
-/**
- * Build tree attention mask
- *
- * In tree attention:
- * - All tokens attend to the prompt (positions 0 to promptLen-1)
- * - Tree tokens attend to their ancestors in the tree
- * - Maintains causal property within the tree structure
- */
-export declare function buildTreeMask(config: TreeAttentionConfig): BlockSparseCSR;
-/**
- * Build a simple chain tree (linear speculation)
- * Each token depends on the previous one
- */
-export declare function buildChainTree(numSpecTokens: number): TreeNode[];
-/**
- * Build a wide tree (parallel speculation)
- * All speculative tokens depend only on the prompt
- */
-export declare function buildWideTree(numSpecTokens: number): TreeNode[];
-/**
- * Build a binary tree for speculation
- */
-export declare function buildBinaryTree(depth: number): TreeNode[];
-/**
- * Build Medusa-style tree
- * Multiple heads predict tokens at different positions
- */
-export declare function buildMedusaTree(numHeads: number, tokensPerHead: number): TreeNode[];
-/**
- * Calculate tree sparsity ratio
- */
-export declare function getTreeSparsity(config: TreeAttentionConfig): number;
-/**
- * Validate tree structure
- */
-export declare function validateTree(tree: TreeNode[]): boolean;

package/dist/attention/cascaded-inference.d.ts

@@ -1,29 +0,0 @@
-/**
- * Cascaded Inference - TDR-safe attention for very long sequences
- * Splits attention computation across multiple passes with browser yields
- */
-import type { WebInferDevice } from "../core/device.ts";
-import { Tensor } from "../core/tensor.ts";
-export interface CascadedAttentionConfig {
-    numHeads: number;
-    headDim: number;
-    seqLen: number;
-    scale?: number;
-    causal?: boolean;
-}
-/**
- * Cascaded Attention - Safe for very long sequences
- * Uses Split-K strategy to prevent TDR (GPU timeout)
- *
- * @param device WebInfer device
- * @param q Query tensor [seqLen, numHeads, headDim]
- * @param k Key tensor [seqLen, numHeads, headDim]
- * @param v Value tensor [seqLen, numHeads, headDim]
- * @param config Attention configuration
- * @param onProgress Optional progress callback
- */
-export declare function cascadedAttention(device: WebInferDevice, q: Tensor, k: Tensor, v: Tensor, config: CascadedAttentionConfig, onProgress?: (chunk: number, total: number) => void): Promise<Tensor>;
-/**
- * CPU reference implementation for verification
- */
-export declare function cascadedAttentionCPU(q: Float32Array, k: Float32Array, v: Float32Array, seqLen: number, numHeads: number, headDim: number, causal?: boolean): Float32Array;

package/dist/attention/flash-attention.d.ts

@@ -1,30 +0,0 @@
-/**
- * FlashAttention Implementation for WebGPU
- * Memory-efficient attention using online softmax and tiling
- */
-import type { WebInferDevice } from "../core/device.ts";
-import { Tensor } from "../core/tensor.ts";
-import type { AttentionPattern } from "./block-sparse/format.ts";
-export interface AttentionConfig {
-    numHeads: number;
-    headDim: number;
-    seqLen: number;
-    scale?: number;
-    pattern?: AttentionPattern;
-    blockSize?: number;
-}
-/**
- * FlashAttention forward pass
- * Computes: softmax(Q @ K^T / sqrt(d)) @ V
- *
- * @param device WebInfer device
- * @param q Query tensor [batch, seqLen, numHeads, headDim]
- * @param k Key tensor [batch, seqLen, numHeads, headDim]
- * @param v Value tensor [batch, seqLen, numHeads, headDim]
- * @param config Attention configuration
- */
-export declare function flashAttention(device: WebInferDevice, q: Tensor, k: Tensor, v: Tensor, config: AttentionConfig): Promise<Tensor>;
-/**
- * CPU reference implementation for verification
- */
-export declare function attentionCPU(q: Float32Array, k: Float32Array, v: Float32Array, seqLen: number, numHeads: number, headDim: number, causal?: boolean): Float32Array;