webinfer 0.0.1

package/dist/index.js

@@ -0,0 +1,4228 @@
+// src/core/device.ts
+class WebInferDevice {
+  _device;
+  _info;
+  constructor(device, info) {
+    this._device = device;
+    this._info = info;
+  }
+  static async create() {
+    if (!navigator.gpu) {
+      throw new Error("WebGPU not supported in this browser");
+    }
+    const adapter = await navigator.gpu.requestAdapter({
+      powerPreference: "high-performance"
+    });
+    if (!adapter) {
+      throw new Error("No WebGPU adapter found");
+    }
+    const device = await adapter.requestDevice({
+      requiredLimits: {
+        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+        maxBufferSize: adapter.limits.maxBufferSize,
+        maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,
+        maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup
+      }
+    });
+    device.lost.then((info2) => {
+      console.error("WebGPU device lost:", info2.message);
+    });
+    const info = WebInferDevice.detectDeviceInfo(adapter, device);
+    return new WebInferDevice(device, info);
+  }
+  static detectDeviceInfo(adapter, device) {
+    const adapterInfo = adapter.info;
+    const vendorLower = (adapterInfo.vendor || "").toLowerCase();
+    const architectureLower = (adapterInfo.architecture || "").toLowerCase();
+    let vendor = "unknown";
+    if (vendorLower.includes("apple") || architectureLower.includes("apple")) {
+      vendor = "apple";
+    } else if (vendorLower.includes("nvidia") || architectureLower.includes("nvidia")) {
+      vendor = "nvidia";
+    } else if (vendorLower.includes("intel") || architectureLower.includes("intel")) {
+      vendor = "intel";
+    } else if (vendorLower.includes("amd") || vendorLower.includes("advanced micro")) {
+      vendor = "amd";
+    }
+    return {
+      vendor,
+      architecture: adapterInfo.architecture || "unknown",
+      maxWorkgroupSize: device.limits.maxComputeWorkgroupSizeX,
+      maxComputeInvocationsPerWorkgroup: device.limits.maxComputeInvocationsPerWorkgroup,
+      maxStorageBufferBindingSize: device.limits.maxStorageBufferBindingSize
+    };
+  }
+  get device() {
+    return this._device;
+  }
+  get info() {
+    return this._info;
+  }
+  get limits() {
+    return this._device.limits;
+  }
+  createCommandEncoder() {
+    return this._device.createCommandEncoder();
+  }
+  submit(commandBuffers) {
+    this._device.queue.submit(commandBuffers);
+  }
+  dispose() {
+    this._device.destroy();
+  }
+}
+// src/core/tensor.ts
+var DTYPE_BYTES = {
+  f32: 4,
+  f16: 2,
+  i32: 4,
+  u32: 4
+};
+
+class Tensor {
+  _device;
+  _shape;
+  _dtype;
+  _buffer;
+  _disposed = false;
+  constructor(device, shape, dtype = "f32", data) {
+    this._device = device;
+    this._shape = Object.freeze([...shape]);
+    this._dtype = dtype;
+    const byteSize = this.numel * DTYPE_BYTES[dtype];
+    const alignedSize = Math.ceil(byteSize / 16) * 16;
+    this._buffer = device.device.createBuffer({
+      size: alignedSize,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+      mappedAtCreation: !!data
+    });
+    if (data) {
+      const mapped = new Float32Array(this._buffer.getMappedRange());
+      mapped.set(data);
+      this._buffer.unmap();
+    }
+  }
+  static async fromArray(device, shape, data, dtype = "f32") {
+    return new Tensor(device, shape, dtype, data);
+  }
+  static zeros(device, shape, dtype = "f32") {
+    const numel = shape.reduce((a, b) => a * b, 1);
+    const data = new Float32Array(numel);
+    return new Tensor(device, shape, dtype, data);
+  }
+  static rand(device, shape, dtype = "f32") {
+    const numel = shape.reduce((a, b) => a * b, 1);
+    const data = new Float32Array(numel);
+    for (let i = 0;i < numel; i++) {
+      data[i] = Math.random();
+    }
+    return new Tensor(device, shape, dtype, data);
+  }
+  get shape() {
+    return this._shape;
+  }
+  get dtype() {
+    return this._dtype;
+  }
+  get numel() {
+    return this._shape.reduce((a, b) => a * b, 1);
+  }
+  get byteSize() {
+    return this.numel * DTYPE_BYTES[this._dtype];
+  }
+  get buffer() {
+    if (this._disposed) {
+      throw new Error("Tensor has been disposed");
+    }
+    return this._buffer;
+  }
+  get device() {
+    return this._device;
+  }
+  async toArray() {
+    if (this._disposed) {
+      throw new Error("Tensor has been disposed");
+    }
+    const byteSize = this.byteSize;
+    const alignedSize = Math.ceil(byteSize / 16) * 16;
+    const stagingBuffer = this._device.device.createBuffer({
+      size: alignedSize,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    });
+    const encoder = this._device.createCommandEncoder();
+    encoder.copyBufferToBuffer(this._buffer, 0, stagingBuffer, 0, alignedSize);
+    this._device.submit([encoder.finish()]);
+    await stagingBuffer.mapAsync(GPUMapMode.READ);
+    const data = new Float32Array(stagingBuffer.getMappedRange().slice(0));
+    stagingBuffer.unmap();
+    stagingBuffer.destroy();
+    return data.slice(0, this.numel);
+  }
+  reshape(newShape) {
+    const newNumel = newShape.reduce((a, b) => a * b, 1);
+    if (newNumel !== this.numel) {
+      throw new Error(`Cannot reshape tensor of size ${this.numel} to shape [${newShape}]`);
+    }
+    const view = Object.create(Tensor.prototype);
+    view._device = this._device;
+    view._shape = Object.freeze([...newShape]);
+    view._dtype = this._dtype;
+    view._buffer = this._buffer;
+    view._disposed = false;
+    return view;
+  }
+  dispose() {
+    if (!this._disposed) {
+      this._buffer.destroy();
+      this._disposed = true;
+    }
+  }
+}
+// src/core/buffer-pool.ts
+class BufferPool {
+  device;
+  pools = new Map;
+  sizeClasses;
+  constructor(device) {
+    this.device = device;
+    this.sizeClasses = [];
+    for (let size = 256;size <= 1024 * 1024 * 1024; size *= 2) {
+      this.sizeClasses.push(size);
+    }
+  }
+  getSizeClass(size) {
+    for (const sizeClass of this.sizeClasses) {
+      if (sizeClass >= size) {
+        return sizeClass;
+      }
+    }
+    return Math.pow(2, Math.ceil(Math.log2(size)));
+  }
+  acquire(size, usage) {
+    const sizeClass = this.getSizeClass(size);
+    const pool = this.pools.get(sizeClass);
+    if (pool) {
+      for (const pooled2 of pool) {
+        if (!pooled2.inUse && (pooled2.buffer.usage & usage) === usage) {
+          pooled2.inUse = true;
+          return pooled2.buffer;
+        }
+      }
+    }
+    const buffer = this.device.createBuffer({
+      size: sizeClass,
+      usage: usage | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+    const pooled = {
+      buffer,
+      size: sizeClass,
+      inUse: true
+    };
+    if (!this.pools.has(sizeClass)) {
+      this.pools.set(sizeClass, []);
+    }
+    this.pools.get(sizeClass).push(pooled);
+    return buffer;
+  }
+  release(buffer) {
+    for (const pool of this.pools.values()) {
+      for (const pooled of pool) {
+        if (pooled.buffer === buffer) {
+          pooled.inUse = false;
+          return;
+        }
+      }
+    }
+  }
+  getStats() {
+    let totalBuffers = 0;
+    let inUse = 0;
+    let totalBytes = 0;
+    for (const pool of this.pools.values()) {
+      for (const pooled of pool) {
+        totalBuffers++;
+        totalBytes += pooled.size;
+        if (pooled.inUse)
+          inUse++;
+      }
+    }
+    return { totalBuffers, inUse, totalBytes };
+  }
+  dispose() {
+    for (const pool of this.pools.values()) {
+      for (const pooled of pool) {
+        pooled.buffer.destroy();
+      }
+    }
+    this.pools.clear();
+  }
+}
+// src/jit/kernel-cache.ts
+class KernelCache {
+  device;
+  cache = new Map;
+  hits = 0;
+  misses = 0;
+  constructor(device) {
+    this.device = device;
+  }
+  getOrCreate(key, createFn) {
+    const existing = this.cache.get(key);
+    if (existing) {
+      this.hits++;
+      return existing;
+    }
+    this.misses++;
+    const pipeline = createFn();
+    this.cache.set(key, pipeline);
+    return pipeline;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  get(key) {
+    const pipeline = this.cache.get(key);
+    if (pipeline)
+      this.hits++;
+    return pipeline;
+  }
+  set(key, pipeline) {
+    this.cache.set(key, pipeline);
+  }
+  getStats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.cache.size
+    };
+  }
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+}
+// src/jit/compiler.ts
+class WGSLCompiler {
+  device;
+  cache;
+  deviceInfo;
+  constructor(device, cache, deviceInfo) {
+    this.device = device;
+    this.cache = cache;
+    this.deviceInfo = deviceInfo;
+  }
+  selectTileSize(config) {
+    if (this.deviceInfo.vendor === "apple") {
+      return { tileM: 16, tileN: 16, tileK: 16 };
+    } else if (this.deviceInfo.vendor === "nvidia") {
+      return { tileM: 32, tileN: 32, tileK: 16 };
+    }
+    return { tileM: 16, tileN: 16, tileK: 16 };
+  }
+  compileMatMul(config) {
+    const tiles = this.selectTileSize(config);
+    const tileM = config.tileM ?? tiles.tileM;
+    const tileN = config.tileN ?? tiles.tileN;
+    const tileK = config.tileK ?? tiles.tileK;
+    const key = `matmul_${config.M}_${config.N}_${config.K}_${tileM}_${tileN}_${tileK}`;
+    return this.cache.getOrCreate(key, () => {
+      const wgsl = this.generateMatMulWGSL(config.M, config.N, config.K, tileM, tileN, tileK);
+      const shaderModule = this.device.createShaderModule({
+        code: wgsl
+      });
+      return this.device.createComputePipeline({
+        layout: "auto",
+        compute: {
+          module: shaderModule,
+          entryPoint: "main"
+        }
+      });
+    });
+  }
+  generateMatMulWGSL(M, N, K, tileM, tileN, tileK) {
+    const workgroupSizeX = tileN;
+    const workgroupSizeY = tileM;
+    return `
+// WebInfer MatMul Kernel
+// C[M,N] = A[M,K] @ B[K,N]
+// Tile size: ${tileM}x${tileN}x${tileK}
+
+struct Params {
+  M: u32,
+  N: u32,
+  K: u32,
+}
+
+@group(0) @binding(0) var<storage, read> A: array<f32>;
+@group(0) @binding(1) var<storage, read> B: array<f32>;
+@group(0) @binding(2) var<storage, read_write> C: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+var<workgroup> tileA: array<f32, ${tileM * tileK}>;
+var<workgroup> tileB: array<f32, ${tileK * tileN}>;
+
+@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY})
+fn main(
+  @builtin(global_invocation_id) global_id: vec3<u32>,
+  @builtin(local_invocation_id) local_id: vec3<u32>,
+  @builtin(workgroup_id) workgroup_id: vec3<u32>
+) {
+  let row = workgroup_id.y * ${tileM}u + local_id.y;
+  let col = workgroup_id.x * ${tileN}u + local_id.x;
+
+  let localRow = local_id.y;
+  let localCol = local_id.x;
+
+  var sum: f32 = 0.0;
+
+  let numTiles = (params.K + ${tileK}u - 1u) / ${tileK}u;
+
+  for (var t: u32 = 0u; t < numTiles; t = t + 1u) {
+    // Load tile of A into shared memory
+    let aRow = row;
+    let aCol = t * ${tileK}u + localCol;
+    if (aRow < params.M && aCol < params.K) {
+      tileA[localRow * ${tileK}u + localCol] = A[aRow * params.K + aCol];
+    } else {
+      tileA[localRow * ${tileK}u + localCol] = 0.0;
+    }
+
+    // Load tile of B into shared memory
+    let bRow = t * ${tileK}u + localRow;
+    let bCol = col;
+    if (bRow < params.K && bCol < params.N) {
+      tileB[localRow * ${tileN}u + localCol] = B[bRow * params.N + bCol];
+    } else {
+      tileB[localRow * ${tileN}u + localCol] = 0.0;
+    }
+
+    workgroupBarrier();
+
+    // Compute partial dot product
+    for (var k: u32 = 0u; k < ${tileK}u; k = k + 1u) {
+      sum = sum + tileA[localRow * ${tileK}u + k] * tileB[k * ${tileN}u + localCol];
+    }
+
+    workgroupBarrier();
+  }
+
+  // Write result
+  if (row < params.M && col < params.N) {
+    C[row * params.N + col] = sum;
+  }
+}
+`;
+  }
+  getCacheStats() {
+    return this.cache.getStats();
+  }
+}
+// src/ops/matmul.ts
+var compilerInstance = null;
+var cacheInstance = null;
+function getCompiler(device) {
+  if (!compilerInstance || !cacheInstance) {
+    cacheInstance = new KernelCache(device.device);
+    compilerInstance = new WGSLCompiler(device.device, cacheInstance, device.info);
+  }
+  return compilerInstance;
+}
+async function matmul(device, a, b) {
+  if (a.shape.length !== 2 || b.shape.length !== 2) {
+    throw new Error("matmul requires 2D tensors");
+  }
+  const [M, K1] = a.shape;
+  const [K2, N] = b.shape;
+  if (K1 !== K2) {
+    throw new Error(`matmul shape mismatch: [${M},${K1}] @ [${K2},${N}] - inner dimensions must match`);
+  }
+  const K = K1;
+  const c = Tensor.zeros(device, [M, N]);
+  const compiler = getCompiler(device);
+  const pipeline = compiler.compileMatMul({ M, N, K });
+  const paramsBuffer = device.device.createBuffer({
+    size: 16,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([M, N, K]));
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: a.buffer } },
+      { binding: 1, resource: { buffer: b.buffer } },
+      { binding: 2, resource: { buffer: c.buffer } },
+      { binding: 3, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  const tileSize = 16;
+  const workgroupsX = Math.ceil(N / tileSize);
+  const workgroupsY = Math.ceil(M / tileSize);
+  pass.dispatchWorkgroups(workgroupsX, workgroupsY);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return c;
+}
+function matmulCPU(a, b, M, N, K) {
+  const c = new Float32Array(M * N);
+  for (let i = 0;i < M; i++) {
+    for (let j = 0;j < N; j++) {
+      let sum = 0;
+      for (let k = 0;k < K; k++) {
+        sum += a[i * K + k] * b[k * N + j];
+      }
+      c[i * N + j] = sum;
+    }
+  }
+  return c;
+}
+function getMatMulCacheStats(device) {
+  const compiler = getCompiler(device);
+  return compiler.getCacheStats();
+}
+// src/ops/normalization.ts
+var kernelCache = null;
+function getCache(device) {
+  if (!kernelCache) {
+    kernelCache = new KernelCache(device);
+  }
+  return kernelCache;
+}
+function layerNormCPU(x, weight, bias, shape, eps = 0.00001) {
+  const lastDim = shape[shape.length - 1];
+  const outerSize = x.length / lastDim;
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < outerSize; i++) {
+    const offset = i * lastDim;
+    let mean = 0;
+    for (let j = 0;j < lastDim; j++) {
+      mean += x[offset + j];
+    }
+    mean /= lastDim;
+    let variance = 0;
+    for (let j = 0;j < lastDim; j++) {
+      const diff = x[offset + j] - mean;
+      variance += diff * diff;
+    }
+    variance /= lastDim;
+    const invStd = 1 / Math.sqrt(variance + eps);
+    for (let j = 0;j < lastDim; j++) {
+      const normalized = (x[offset + j] - mean) * invStd;
+      output[offset + j] = normalized * weight[j] + (bias ? bias[j] : 0);
+    }
+  }
+  return output;
+}
+function rmsNormCPU(x, weight, shape, eps = 0.00001) {
+  const lastDim = shape[shape.length - 1];
+  const outerSize = x.length / lastDim;
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < outerSize; i++) {
+    const offset = i * lastDim;
+    let sumSq = 0;
+    for (let j = 0;j < lastDim; j++) {
+      sumSq += x[offset + j] * x[offset + j];
+    }
+    const rms = Math.sqrt(sumSq / lastDim + eps);
+    const invRms = 1 / rms;
+    for (let j = 0;j < lastDim; j++) {
+      output[offset + j] = x[offset + j] * invRms * weight[j];
+    }
+  }
+  return output;
+}
+async function layerNorm(device, x, weight, bias, eps = 0.00001) {
+  const lastDim = x.shape[x.shape.length - 1];
+  const outerSize = x.numel / lastDim;
+  const cache = getCache(device.device);
+  const pipeline = cache.getOrCreate(`layernorm_${lastDim}_${bias !== null}`, () => compileLayerNormKernel(device.device, lastDim, bias !== null));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Float32Array([outerSize, lastDim, eps, 0]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const entries = [
+    { binding: 0, resource: { buffer: x.buffer } },
+    { binding: 1, resource: { buffer: weight.buffer } },
+    { binding: 2, resource: { buffer: output.buffer } },
+    { binding: 3, resource: { buffer: paramsBuffer } }
+  ];
+  if (bias) {
+    entries.push({ binding: 4, resource: { buffer: bias.buffer } });
+  }
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(outerSize);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+async function rmsNorm(device, x, weight, eps = 0.00001) {
+  const lastDim = x.shape[x.shape.length - 1];
+  const outerSize = x.numel / lastDim;
+  const cache = getCache(device.device);
+  const pipeline = cache.getOrCreate(`rmsnorm_${lastDim}`, () => compileRMSNormKernel(device.device, lastDim));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Float32Array([outerSize, lastDim, eps, 0]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: weight.buffer } },
+      { binding: 2, resource: { buffer: output.buffer } },
+      { binding: 3, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(outerSize);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileLayerNormKernel(device, dim, hasBias) {
+  const WORKGROUP_SIZE = 256;
+  const wgsl = `
+struct Params {
+  outerSize: f32,
+  dim: f32,
+  eps: f32,
+  _pad: f32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read> weight: array<f32>;
+@group(0) @binding(2) var<storage, read_write> output: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+${hasBias ? "@group(0) @binding(4) var<storage, read> bias: array<f32>;" : ""}
+
+var<workgroup> shared_sum: array<f32, ${WORKGROUP_SIZE}>;
+var<workgroup> shared_mean: f32;
+
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(
+  @builtin(local_invocation_id) lid: vec3<u32>,
+  @builtin(workgroup_id) wgid: vec3<u32>
+) {
+  let row = wgid.x;
+  let tid = lid.x;
+  let dim = u32(params.dim);
+  let offset = row * dim;
+
+  // === Pass 1: Compute mean ===
+  var partial_sum: f32 = 0.0;
+  for (var i = tid; i < dim; i += ${WORKGROUP_SIZE}u) {
+    partial_sum += x[offset + i];
+  }
+  shared_sum[tid] = partial_sum;
+  workgroupBarrier();
+
+  // Parallel reduction for sum
+  for (var stride = ${WORKGROUP_SIZE / 2}u; stride > 0u; stride >>= 1u) {
+    if (tid < stride) {
+      shared_sum[tid] += shared_sum[tid + stride];
+    }
+    workgroupBarrier();
+  }
+
+  // Store mean for all threads to use
+  if (tid == 0u) {
+    shared_mean = shared_sum[0] / params.dim;
+  }
+  workgroupBarrier();
+  let mean = shared_mean;
+
+  // === Pass 2: Compute variance ===
+  var partial_var: f32 = 0.0;
+  for (var i = tid; i < dim; i += ${WORKGROUP_SIZE}u) {
+    let diff = x[offset + i] - mean;
+    partial_var += diff * diff;
+  }
+  shared_sum[tid] = partial_var;
+  workgroupBarrier();
+
+  // Parallel reduction for variance
+  for (var stride = ${WORKGROUP_SIZE / 2}u; stride > 0u; stride >>= 1u) {
+    if (tid < stride) {
+      shared_sum[tid] += shared_sum[tid + stride];
+    }
+    workgroupBarrier();
+  }
+
+  // Compute inverse standard deviation
+  let inv_std = 1.0 / sqrt(shared_sum[0] / params.dim + params.eps);
+
+  // === Pass 3: Normalize and apply affine transform ===
+  for (var i = tid; i < dim; i += ${WORKGROUP_SIZE}u) {
+    let normalized = (x[offset + i] - mean) * inv_std;
+    ${hasBias ? "output[offset + i] = normalized * weight[i] + bias[i];" : "output[offset + i] = normalized * weight[i];"}
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function compileRMSNormKernel(device, dim) {
+  const WORKGROUP_SIZE = 256;
+  const wgsl = `
+struct Params {
+  outerSize: f32,
+  dim: f32,
+  eps: f32,
+  _pad: f32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read> weight: array<f32>;
+@group(0) @binding(2) var<storage, read_write> output: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+var<workgroup> shared_sum: array<f32, ${WORKGROUP_SIZE}>;
+
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(
+  @builtin(local_invocation_id) lid: vec3<u32>,
+  @builtin(workgroup_id) wgid: vec3<u32>
+) {
+  let row = wgid.x;
+  let tid = lid.x;
+  let dim = u32(params.dim);
+  let offset = row * dim;
+
+  // Each thread computes partial sum of squares
+  var partial_sum: f32 = 0.0;
+  for (var i = tid; i < dim; i += ${WORKGROUP_SIZE}u) {
+    let val = x[offset + i];
+    partial_sum += val * val;
+  }
+  shared_sum[tid] = partial_sum;
+  workgroupBarrier();
+
+  // Parallel reduction in shared memory
+  for (var stride = ${WORKGROUP_SIZE / 2}u; stride > 0u; stride >>= 1u) {
+    if (tid < stride) {
+      shared_sum[tid] += shared_sum[tid + stride];
+    }
+    workgroupBarrier();
+  }
+
+  // Compute inverse RMS (thread 0 has the final sum)
+  let inv_rms = 1.0 / sqrt(shared_sum[0] / params.dim + params.eps);
+
+  // All threads normalize their portion
+  for (var i = tid; i < dim; i += ${WORKGROUP_SIZE}u) {
+    output[offset + i] = x[offset + i] * inv_rms * weight[i];
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+// src/ops/rope.ts
+var kernelCache2 = null;
+function getCache2(device) {
+  if (!kernelCache2) {
+    kernelCache2 = new KernelCache(device);
+  }
+  return kernelCache2;
+}
+function computeRoPEFrequencies(config) {
+  const { dim, maxSeqLen, base = 1e4, scaling = 1 } = config;
+  const halfDim = dim / 2;
+  const invFreq = new Float32Array(halfDim);
+  for (let i = 0;i < halfDim; i++) {
+    invFreq[i] = 1 / Math.pow(base, 2 * i / dim);
+  }
+  const cos = new Float32Array(maxSeqLen * halfDim);
+  const sin = new Float32Array(maxSeqLen * halfDim);
+  for (let pos = 0;pos < maxSeqLen; pos++) {
+    const scaledPos = pos / scaling;
+    for (let i = 0;i < halfDim; i++) {
+      const angle = scaledPos * invFreq[i];
+      cos[pos * halfDim + i] = Math.cos(angle);
+      sin[pos * halfDim + i] = Math.sin(angle);
+    }
+  }
+  return { cos, sin };
+}
+function ropeCPU(x, positions, cos, sin, seqLen, numHeads, headDim) {
+  const halfDim = headDim / 2;
+  const output = new Float32Array(x.length);
+  for (let s = 0;s < seqLen; s++) {
+    const pos = positions[s];
+    const cosOffset = pos * halfDim;
+    const sinOffset = pos * halfDim;
+    for (let h = 0;h < numHeads; h++) {
+      const baseIdx = s * numHeads * headDim + h * headDim;
+      for (let d = 0;d < halfDim; d++) {
+        const x0 = x[baseIdx + d];
+        const x1 = x[baseIdx + halfDim + d];
+        const c = cos[cosOffset + d];
+        const si = sin[sinOffset + d];
+        output[baseIdx + d] = x0 * c - x1 * si;
+        output[baseIdx + halfDim + d] = x0 * si + x1 * c;
+      }
+    }
+  }
+  return output;
+}
+async function rope(device, x, positions, config) {
+  if (x.shape.length !== 3) {
+    throw new Error("RoPE input must be 3D [seqLen, numHeads, headDim]");
+  }
+  const [seqLen, numHeads, headDim] = x.shape;
+  const { cos, sin } = computeRoPEFrequencies(config);
+  const cache = getCache2(device.device);
+  const pipeline = cache.getOrCreate(`rope_${headDim}_${numHeads}`, () => compileRoPEKernel(device.device, headDim, numHeads));
+  const output = Tensor.zeros(device, [seqLen, numHeads, headDim]);
+  const cosBuffer = device.device.createBuffer({
+    size: cos.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(cosBuffer, 0, new Float32Array(cos));
+  const sinBuffer = device.device.createBuffer({
+    size: sin.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(sinBuffer, 0, new Float32Array(sin));
+  const params = new Uint32Array([seqLen, numHeads, headDim, headDim / 2]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: positions.buffer } },
+      { binding: 2, resource: { buffer: cosBuffer } },
+      { binding: 3, resource: { buffer: sinBuffer } },
+      { binding: 4, resource: { buffer: output.buffer } },
+      { binding: 5, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(seqLen / 64), numHeads);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  cosBuffer.destroy();
+  sinBuffer.destroy();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileRoPEKernel(device, headDim, numHeads) {
+  const halfDim = headDim / 2;
+  const wgsl = `
+struct Params {
+  seqLen: u32,
+  numHeads: u32,
+  headDim: u32,
+  halfDim: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read> positions: array<u32>;
+@group(0) @binding(2) var<storage, read> cos: array<f32>;
+@group(0) @binding(3) var<storage, read> sin: array<f32>;
+@group(0) @binding(4) var<storage, read_write> output: array<f32>;
+@group(0) @binding(5) var<uniform> params: Params;
+
+@compute @workgroup_size(64)
+fn main(
+  @builtin(global_invocation_id) gid: vec3<u32>,
+  @builtin(workgroup_id) wgid: vec3<u32>
+) {
+  let seqIdx = gid.x;
+  let headIdx = wgid.y;
+
+  if (seqIdx >= params.seqLen) {
+    return;
+  }
+
+  let pos = positions[seqIdx];
+  let halfDim = params.halfDim;
+  let headDim = params.headDim;
+  let numHeads = params.numHeads;
+
+  let baseIdx = seqIdx * numHeads * headDim + headIdx * headDim;
+  let freqOffset = pos * halfDim;
+
+  // Apply rotation to pairs
+  for (var d = 0u; d < halfDim; d = d + 1u) {
+    let x0 = x[baseIdx + d];
+    let x1 = x[baseIdx + halfDim + d];
+    let c = cos[freqOffset + d];
+    let s = sin[freqOffset + d];
+
+    output[baseIdx + d] = x0 * c - x1 * s;
+    output[baseIdx + halfDim + d] = x0 * s + x1 * c;
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: {
+      module: shaderModule,
+      entryPoint: "main"
+    }
+  });
+}
+// src/ops/activations.ts
+var kernelCache3 = null;
+function getCache3(device) {
+  if (!kernelCache3) {
+    kernelCache3 = new KernelCache(device);
+  }
+  return kernelCache3;
+}
+function geluCPU(x) {
+  const output = new Float32Array(x.length);
+  const sqrt2OverPi = Math.sqrt(2 / Math.PI);
+  for (let i = 0;i < x.length; i++) {
+    const xi = x[i];
+    const inner = sqrt2OverPi * (xi + 0.044715 * xi * xi * xi);
+    output[i] = xi * 0.5 * (1 + Math.tanh(inner));
+  }
+  return output;
+}
+function geluExactCPU(x) {
+  const output = new Float32Array(x.length);
+  const sqrt2 = Math.sqrt(2);
+  for (let i = 0;i < x.length; i++) {
+    const xi = x[i];
+    output[i] = xi * 0.5 * (1 + erf(xi / sqrt2));
+  }
+  return output;
+}
+function erf(x) {
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  x = Math.abs(x);
+  const t = 1 / (1 + p * x);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+  return sign * y;
+}
+function siluCPU(x) {
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < x.length; i++) {
+    const xi = x[i];
+    output[i] = xi / (1 + Math.exp(-xi));
+  }
+  return output;
+}
+function reluCPU(x) {
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < x.length; i++) {
+    output[i] = Math.max(0, x[i]);
+  }
+  return output;
+}
+function sigmoidCPU(x) {
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < x.length; i++) {
+    output[i] = 1 / (1 + Math.exp(-x[i]));
+  }
+  return output;
+}
+async function gelu(device, x) {
+  const cache = getCache3(device.device);
+  const pipeline = cache.getOrCreate("gelu", () => compileGeluKernel(device.device));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Uint32Array([x.numel]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(x.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+async function silu(device, x) {
+  const cache = getCache3(device.device);
+  const pipeline = cache.getOrCreate("silu", () => compileSiluKernel(device.device));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Uint32Array([x.numel]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(x.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+async function relu(device, x) {
+  const cache = getCache3(device.device);
+  const pipeline = cache.getOrCreate("relu", () => compileReluKernel(device.device));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Uint32Array([x.numel]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(x.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileGeluKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+const SQRT_2_OVER_PI: f32 = 0.7978845608;
+const COEFF: f32 = 0.044715;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+
+  let xi = x[idx];
+  let inner = SQRT_2_OVER_PI * (xi + COEFF * xi * xi * xi);
+  output[idx] = xi * 0.5 * (1.0 + tanh(inner));
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function compileSiluKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+
+  let xi = x[idx];
+  // SiLU: x * sigmoid(x) = x / (1 + exp(-x))
+  output[idx] = xi / (1.0 + exp(-xi));
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function compileReluKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+
+  output[idx] = max(0.0, x[idx]);
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+// src/ops/softmax.ts
+var kernelCache4 = null;
+function getCache4(device) {
+  if (!kernelCache4) {
+    kernelCache4 = new KernelCache(device);
+  }
+  return kernelCache4;
+}
+function softmaxCPU(x, shape) {
+  const lastDim = shape[shape.length - 1];
+  const outerSize = x.length / lastDim;
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < outerSize; i++) {
+    const offset = i * lastDim;
+    let maxVal = -Infinity;
+    for (let j = 0;j < lastDim; j++) {
+      maxVal = Math.max(maxVal, x[offset + j]);
+    }
+    let sumExp = 0;
+    for (let j = 0;j < lastDim; j++) {
+      const expVal = Math.exp(x[offset + j] - maxVal);
+      output[offset + j] = expVal;
+      sumExp += expVal;
+    }
+    for (let j = 0;j < lastDim; j++) {
+      output[offset + j] = output[offset + j] / sumExp;
+    }
+  }
+  return output;
+}
+function logSoftmaxCPU(x, shape) {
+  const lastDim = shape[shape.length - 1];
+  const outerSize = x.length / lastDim;
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < outerSize; i++) {
+    const offset = i * lastDim;
+    let maxVal = -Infinity;
+    for (let j = 0;j < lastDim; j++) {
+      maxVal = Math.max(maxVal, x[offset + j]);
+    }
+    let sumExp = 0;
+    for (let j = 0;j < lastDim; j++) {
+      sumExp += Math.exp(x[offset + j] - maxVal);
+    }
+    const logSumExp = maxVal + Math.log(sumExp);
+    for (let j = 0;j < lastDim; j++) {
+      output[offset + j] = x[offset + j] - logSumExp;
+    }
+  }
+  return output;
+}
+async function softmaxGPU(device, x) {
+  const lastDim = x.shape[x.shape.length - 1];
+  const outerSize = x.numel / lastDim;
+  const cache = getCache4(device.device);
+  const pipeline = cache.getOrCreate(`softmax_${lastDim}`, () => compileSoftmaxKernel(device.device, lastDim));
+  const output = Tensor.zeros(device, [...x.shape]);
+  const params = new Uint32Array([outerSize, lastDim]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(outerSize);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileSoftmaxKernel(device, dim) {
+  const wgsl = `
+struct Params {
+  outerSize: u32,
+  dim: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.outerSize) {
+    return;
+  }
+
+  let dim = params.dim;
+  let offset = idx * dim;
+
+  // Find max
+  var maxVal: f32 = x[offset];
+  for (var j = 1u; j < dim; j = j + 1u) {
+    maxVal = max(maxVal, x[offset + j]);
+  }
+
+  // Compute exp and sum
+  var sumExp: f32 = 0.0;
+  for (var j = 0u; j < dim; j = j + 1u) {
+    let expVal = exp(x[offset + j] - maxVal);
+    output[offset + j] = expVal;
+    sumExp = sumExp + expVal;
+  }
+
+  // Normalize
+  let invSum = 1.0 / sumExp;
+  for (var j = 0u; j < dim; j = j + 1u) {
+    output[offset + j] = output[offset + j] * invSum;
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+// src/ops/elementwise.ts
+var kernelCache5 = null;
+function getCache5(device) {
+  if (!kernelCache5) {
+    kernelCache5 = new KernelCache(device);
+  }
+  return kernelCache5;
+}
+function addCPU(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Shape mismatch: ${a.length} vs ${b.length}`);
+  }
+  const output = new Float32Array(a.length);
+  for (let i = 0;i < a.length; i++) {
+    output[i] = a[i] + b[i];
+  }
+  return output;
+}
+function mulCPU(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Shape mismatch: ${a.length} vs ${b.length}`);
+  }
+  const output = new Float32Array(a.length);
+  for (let i = 0;i < a.length; i++) {
+    output[i] = a[i] * b[i];
+  }
+  return output;
+}
+function scaleCPU(a, scalar) {
+  const output = new Float32Array(a.length);
+  for (let i = 0;i < a.length; i++) {
+    output[i] = a[i] * scalar;
+  }
+  return output;
+}
+function addScalarCPU(a, scalar) {
+  const output = new Float32Array(a.length);
+  for (let i = 0;i < a.length; i++) {
+    output[i] = a[i] + scalar;
+  }
+  return output;
+}
+function fmaCPU(a, b, c) {
+  if (a.length !== b.length || a.length !== c.length) {
+    throw new Error("Shape mismatch");
+  }
+  const output = new Float32Array(a.length);
+  for (let i = 0;i < a.length; i++) {
+    output[i] = a[i] * b[i] + c[i];
+  }
+  return output;
+}
+async function add(device, a, b) {
+  if (a.numel !== b.numel) {
+    throw new Error(`Shape mismatch: ${a.shape} vs ${b.shape}`);
+  }
+  const cache = getCache5(device.device);
+  const pipeline = cache.getOrCreate("add", () => compileAddKernel(device.device));
+  const output = Tensor.zeros(device, [...a.shape]);
+  const params = new Uint32Array([a.numel]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: a.buffer } },
+      { binding: 1, resource: { buffer: b.buffer } },
+      { binding: 2, resource: { buffer: output.buffer } },
+      { binding: 3, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(a.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+async function mul(device, a, b) {
+  if (a.numel !== b.numel) {
+    throw new Error(`Shape mismatch: ${a.shape} vs ${b.shape}`);
+  }
+  const cache = getCache5(device.device);
+  const pipeline = cache.getOrCreate("mul", () => compileMulKernel(device.device));
+  const output = Tensor.zeros(device, [...a.shape]);
+  const params = new Uint32Array([a.numel]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: a.buffer } },
+      { binding: 1, resource: { buffer: b.buffer } },
+      { binding: 2, resource: { buffer: output.buffer } },
+      { binding: 3, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(a.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+async function scale(device, a, scalar) {
+  const cache = getCache5(device.device);
+  const pipeline = cache.getOrCreate("scale", () => compileScaleKernel(device.device));
+  const output = Tensor.zeros(device, [...a.shape]);
+  const params = new Float32Array([a.numel, scalar]);
+  const paramsBuffer = device.device.createBuffer({
+    size: 8,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([a.numel]));
+  device.device.queue.writeBuffer(paramsBuffer, 4, new Float32Array([scalar]));
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: a.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(a.numel / 256));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileAddKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> output: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+  output[idx] = a[idx] + b[idx];
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function compileMulKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+}
+
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> output: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+  output[idx] = a[idx] * b[idx];
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function compileScaleKernel(device) {
+  const wgsl = `
+struct Params {
+  size: u32,
+  scalar: f32,
+}
+
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let idx = gid.x;
+  if (idx >= params.size) {
+    return;
+  }
+  output[idx] = a[idx] * params.scalar;
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+// src/ops/embedding.ts
+var kernelCache6 = null;
+function getCache6(device) {
+  if (!kernelCache6) {
+    kernelCache6 = new KernelCache(device);
+  }
+  return kernelCache6;
+}
+function embeddingCPU(embeddings, tokens, embeddingDim) {
+  const seqLen = tokens.length;
+  const output = new Float32Array(seqLen * embeddingDim);
+  for (let i = 0;i < seqLen; i++) {
+    const tokenId = tokens[i];
+    const srcOffset = tokenId * embeddingDim;
+    const dstOffset = i * embeddingDim;
+    for (let j = 0;j < embeddingDim; j++) {
+      output[dstOffset + j] = embeddings[srcOffset + j];
+    }
+  }
+  return output;
+}
+async function embedding(device, embeddings, tokens) {
+  if (embeddings.shape.length !== 2) {
+    throw new Error("Embedding table must be 2D [vocabSize, embeddingDim]");
+  }
+  if (tokens.shape.length !== 1) {
+    throw new Error("Tokens must be 1D [seqLen]");
+  }
+  const [, embeddingDim] = embeddings.shape;
+  const seqLen = tokens.shape[0];
+  const cache = getCache6(device.device);
+  const pipeline = cache.getOrCreate(`embedding_${embeddingDim}`, () => compileEmbeddingKernel(device.device, embeddingDim));
+  const output = Tensor.zeros(device, [seqLen, embeddingDim]);
+  const params = new Uint32Array([seqLen, embeddingDim]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: embeddings.buffer } },
+      { binding: 1, resource: { buffer: tokens.buffer } },
+      { binding: 2, resource: { buffer: output.buffer } },
+      { binding: 3, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(seqLen);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function compileEmbeddingKernel(device, embeddingDim) {
+  const wgsl = `
+struct Params {
+  seqLen: u32,
+  embeddingDim: u32,
+}
+
+@group(0) @binding(0) var<storage, read> embeddings: array<f32>;
+@group(0) @binding(1) var<storage, read> tokens: array<u32>;
+@group(0) @binding(2) var<storage, read_write> output: array<f32>;
+@group(0) @binding(3) var<uniform> params: Params;
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let seqIdx = gid.x;
+  if (seqIdx >= params.seqLen) {
+    return;
+  }
+
+  let tokenId = tokens[seqIdx];
+  let srcOffset = tokenId * params.embeddingDim;
+  let dstOffset = seqIdx * params.embeddingDim;
+
+  for (var j = 0u; j < params.embeddingDim; j = j + 1u) {
+    output[dstOffset + j] = embeddings[srcOffset + j];
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+function batchedEmbeddingCPU(embeddings, tokens, embeddingDim) {
+  const batchSize = tokens.length;
+  const seqLen = tokens[0]?.length ?? 0;
+  const output = new Float32Array(batchSize * seqLen * embeddingDim);
+  for (let b = 0;b < batchSize; b++) {
+    for (let i = 0;i < seqLen; i++) {
+      const tokenId = tokens[b][i];
+      const srcOffset = tokenId * embeddingDim;
+      const dstOffset = (b * seqLen + i) * embeddingDim;
+      for (let j = 0;j < embeddingDim; j++) {
+        output[dstOffset + j] = embeddings[srcOffset + j];
+      }
+    }
+  }
+  return output;
+}
+// src/ops/reshape.ts
+var kernelCache7 = null;
+function getCache7(device) {
+  if (!kernelCache7) {
+    kernelCache7 = new KernelCache(device);
+  }
+  return kernelCache7;
+}
+function transpose2DCPU(x, rows, cols) {
+  const output = new Float32Array(x.length);
+  for (let i = 0;i < rows; i++) {
+    for (let j = 0;j < cols; j++) {
+      output[j * rows + i] = x[i * cols + j];
+    }
+  }
+  return output;
+}
+function transposeCPU(x, shape) {
+  if (shape.length < 2) {
+    throw new Error("Transpose requires at least 2D tensor");
+  }
+  const M = shape[shape.length - 2];
+  const N = shape[shape.length - 1];
+  const batchSize = shape.slice(0, -2).reduce((a, b) => a * b, 1);
+  const output = new Float32Array(x.length);
+  const matrixSize = M * N;
+  for (let b = 0;b < batchSize; b++) {
+    const batchOffset = b * matrixSize;
+    for (let i = 0;i < M; i++) {
+      for (let j = 0;j < N; j++) {
+        output[batchOffset + j * M + i] = x[batchOffset + i * N + j];
+      }
+    }
+  }
+  const newShape = [...shape.slice(0, -2), N, M];
+  return { data: output, shape: newShape };
+}
+function reshapeCPU(x, oldShape, newShape) {
+  const oldSize = oldShape.reduce((a, b) => a * b, 1);
+  let inferIdx = -1;
+  let knownSize = 1;
+  for (let i = 0;i < newShape.length; i++) {
+    if (newShape[i] === -1) {
+      if (inferIdx !== -1) {
+        throw new Error("Can only have one -1 in reshape");
+      }
+      inferIdx = i;
+    } else {
+      knownSize *= newShape[i];
+    }
+  }
+  const finalShape = [...newShape];
+  if (inferIdx !== -1) {
+    if (oldSize % knownSize !== 0) {
+      throw new Error(`Cannot reshape ${oldShape} to ${newShape}`);
+    }
+    finalShape[inferIdx] = oldSize / knownSize;
+  }
+  const newSize = finalShape.reduce((a, b) => a * b, 1);
+  if (oldSize !== newSize) {
+    throw new Error(`Shape mismatch: ${oldSize} vs ${newSize}`);
+  }
+  return { data: x, shape: finalShape };
+}
+async function transpose2D(device, x) {
+  if (x.shape.length !== 2) {
+    throw new Error("transpose2D requires 2D tensor");
+  }
+  const [rows, cols] = x.shape;
+  const cache = getCache7(device.device);
+  const pipeline = cache.getOrCreate(`transpose2d_${rows}_${cols}`, () => compileTranspose2DKernel(device.device));
+  const output = Tensor.zeros(device, [cols, rows]);
+  const params = new Uint32Array([rows, cols]);
+  const paramsBuffer = device.device.createBuffer({
+    size: params.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, params);
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: x.buffer } },
+      { binding: 1, resource: { buffer: output.buffer } },
+      { binding: 2, resource: { buffer: paramsBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(Math.ceil(cols / 16), Math.ceil(rows / 16));
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  return output;
+}
+function permuteCPU(x, shape, dims) {
+  if (dims.length !== shape.length) {
+    throw new Error("Permutation must have same length as shape");
+  }
+  const sorted = [...dims].sort((a, b) => a - b);
+  for (let i = 0;i < sorted.length; i++) {
+    if (sorted[i] !== i) {
+      throw new Error("Invalid permutation");
+    }
+  }
+  const newShape = dims.map((d) => shape[d]);
+  const output = new Float32Array(x.length);
+  const oldStrides = computeStrides(shape);
+  const newStrides = computeStrides(newShape);
+  const ndim = shape.length;
+  const indices = new Array(ndim).fill(0);
+  for (let i = 0;i < x.length; i++) {
+    let remaining = i;
+    for (let d = 0;d < ndim; d++) {
+      indices[d] = Math.floor(remaining / newStrides[d]);
+      remaining = remaining % newStrides[d];
+    }
+    let oldIdx = 0;
+    for (let d = 0;d < ndim; d++) {
+      oldIdx += indices[d] * oldStrides[dims[d]];
+    }
+    output[i] = x[oldIdx];
+  }
+  return { data: output, shape: newShape };
+}
+function computeStrides(shape) {
+  const strides = new Array(shape.length);
+  strides[shape.length - 1] = 1;
+  for (let i = shape.length - 2;i >= 0; i--) {
+    strides[i] = strides[i + 1] * shape[i + 1];
+  }
+  return strides;
+}
+function compileTranspose2DKernel(device) {
+  const wgsl = `
+struct Params {
+  rows: u32,
+  cols: u32,
+}
+
+@group(0) @binding(0) var<storage, read> x: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(16, 16)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let col = gid.x;
+  let row = gid.y;
+
+  if (col >= params.cols || row >= params.rows) {
+    return;
+  }
+
+  // Input: [row, col] at row * cols + col
+  // Output: [col, row] at col * rows + row
+  output[col * params.rows + row] = x[row * params.cols + col];
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shaderModule, entryPoint: "main" }
+  });
+}
+// src/quantization/quantize.ts
+function quantizeToInt8(x, groupSize = 128, symmetric = true) {
+  const numGroups = Math.ceil(x.length / groupSize);
+  const scales = new Float32Array(numGroups);
+  const zeros = symmetric ? null : new Float32Array(numGroups);
+  const quantized = new Uint8Array(x.length);
+  for (let g = 0;g < numGroups; g++) {
+    const start = g * groupSize;
+    const end = Math.min(start + groupSize, x.length);
+    let minVal = x[start];
+    let maxVal = x[start];
+    for (let i = start;i < end; i++) {
+      minVal = Math.min(minVal, x[i]);
+      maxVal = Math.max(maxVal, x[i]);
+    }
+    if (symmetric) {
+      const absMax = Math.max(Math.abs(minVal), Math.abs(maxVal));
+      scales[g] = absMax / 127;
+      const scale2 = scales[g];
+      const invScale = scale2 > 0 ? 1 / scale2 : 0;
+      for (let i = start;i < end; i++) {
+        const q = Math.round(x[i] * invScale);
+        quantized[i] = Math.max(0, Math.min(255, q + 128));
+      }
+    } else {
+      scales[g] = (maxVal - minVal) / 255;
+      zeros[g] = minVal;
+      const scale2 = scales[g];
+      const invScale = scale2 > 0 ? 1 / scale2 : 0;
+      for (let i = start;i < end; i++) {
+        const q = Math.round((x[i] - zeros[g]) * invScale);
+        quantized[i] = Math.max(0, Math.min(255, q));
+      }
+    }
+  }
+  return {
+    data: quantized,
+    scales,
+    zeros,
+    shape: [x.length],
+    config: { bits: 8, groupSize, symmetric }
+  };
+}
+function quantizeToInt4(x, groupSize = 128, symmetric = true) {
+  const numGroups = Math.ceil(x.length / groupSize);
+  const scales = new Float32Array(numGroups);
+  const zeros = symmetric ? null : new Float32Array(numGroups);
+  const packedSize = Math.ceil(x.length / 2);
+  const quantized = new Uint8Array(packedSize);
+  for (let g = 0;g < numGroups; g++) {
+    const start = g * groupSize;
+    const end = Math.min(start + groupSize, x.length);
+    let minVal = x[start];
+    let maxVal = x[start];
+    for (let i = start;i < end; i++) {
+      minVal = Math.min(minVal, x[i]);
+      maxVal = Math.max(maxVal, x[i]);
+    }
+    if (symmetric) {
+      const absMax = Math.max(Math.abs(minVal), Math.abs(maxVal));
+      scales[g] = absMax / 7;
+      const scale2 = scales[g];
+      const invScale = scale2 > 0 ? 1 / scale2 : 0;
+      for (let i = start;i < end; i++) {
+        const q = Math.round(x[i] * invScale);
+        const uq = Math.max(0, Math.min(15, q + 8));
+        const byteIdx = Math.floor(i / 2);
+        if (i % 2 === 0) {
+          quantized[byteIdx] = uq;
+        } else {
+          quantized[byteIdx] = quantized[byteIdx] | uq << 4;
+        }
+      }
+    } else {
+      scales[g] = (maxVal - minVal) / 15;
+      zeros[g] = minVal;
+      const scale2 = scales[g];
+      const invScale = scale2 > 0 ? 1 / scale2 : 0;
+      for (let i = start;i < end; i++) {
+        const q = Math.round((x[i] - zeros[g]) * invScale);
+        const uq = Math.max(0, Math.min(15, q));
+        const byteIdx = Math.floor(i / 2);
+        if (i % 2 === 0) {
+          quantized[byteIdx] = uq;
+        } else {
+          quantized[byteIdx] = quantized[byteIdx] | uq << 4;
+        }
+      }
+    }
+  }
+  return {
+    data: quantized,
+    scales,
+    zeros,
+    shape: [x.length],
+    config: { bits: 4, groupSize, symmetric }
+  };
+}
+function dequantizeInt8(qt) {
+  if (qt.config.bits !== 8) {
+    throw new Error("Expected INT8 quantized tensor");
+  }
+  const { data, scales, zeros, config } = qt;
+  const { groupSize, symmetric } = config;
+  const output = new Float32Array(data.length);
+  for (let i = 0;i < data.length; i++) {
+    const g = Math.floor(i / groupSize);
+    const scale2 = scales[g];
+    if (symmetric) {
+      output[i] = (data[i] - 128) * scale2;
+    } else {
+      output[i] = data[i] * scale2 + zeros[g];
+    }
+  }
+  return output;
+}
+function dequantizeInt4(qt) {
+  if (qt.config.bits !== 4) {
+    throw new Error("Expected INT4 quantized tensor");
+  }
+  const { data, scales, zeros, shape, config } = qt;
+  const { groupSize, symmetric } = config;
+  const numElements = shape.reduce((a, b) => a * b, 1);
+  const output = new Float32Array(numElements);
+  for (let i = 0;i < numElements; i++) {
+    const byteIdx = Math.floor(i / 2);
+    const isHigh = i % 2 === 1;
+    let q;
+    if (isHigh) {
+      q = data[byteIdx] >> 4 & 15;
+    } else {
+      q = data[byteIdx] & 15;
+    }
+    const g = Math.floor(i / groupSize);
+    const scale2 = scales[g];
+    if (symmetric) {
+      output[i] = (q - 8) * scale2;
+    } else {
+      output[i] = q * scale2 + zeros[g];
+    }
+  }
+  return output;
+}
+function quantizationError(original, reconstructed) {
+  if (original.length !== reconstructed.length) {
+    throw new Error("Length mismatch");
+  }
+  let sumSqError = 0;
+  for (let i = 0;i < original.length; i++) {
+    const diff = original[i] - reconstructed[i];
+    sumSqError += diff * diff;
+  }
+  return sumSqError / original.length;
+}
+function getMemorySavings(originalBytes, qt) {
+  const dataBytes = qt.data.byteLength;
+  const scaleBytes = qt.scales.byteLength;
+  const zeroBytes = qt.zeros?.byteLength ?? 0;
+  const quantizedBytes = dataBytes + scaleBytes + zeroBytes;
+  return {
+    originalBytes,
+    quantizedBytes,
+    savings: originalBytes - quantizedBytes,
+    ratio: originalBytes / quantizedBytes
+  };
+}
+// src/quantization/qmatmul.ts
+function qmatmulInt8CPU(A, B, M, K, N) {
+  if (B.config.bits !== 8) {
+    throw new Error("Expected INT8 weights");
+  }
+  const { data: Bq, scales, zeros, config } = B;
+  const { groupSize, symmetric } = config;
+  const output = new Float32Array(M * N);
+  for (let m = 0;m < M; m++) {
+    for (let n = 0;n < N; n++) {
+      let sum = 0;
+      for (let k = 0;k < K; k++) {
+        const a = A[m * K + k];
+        const bIdx = k * N + n;
+        const g = Math.floor(bIdx / groupSize);
+        const scale2 = scales[g];
+        let b;
+        if (symmetric) {
+          b = (Bq[bIdx] - 128) * scale2;
+        } else {
+          b = Bq[bIdx] * scale2 + zeros[g];
+        }
+        sum += a * b;
+      }
+      output[m * N + n] = sum;
+    }
+  }
+  return output;
+}
+function qmatmulInt4CPU(A, B, M, K, N) {
+  if (B.config.bits !== 4) {
+    throw new Error("Expected INT4 weights");
+  }
+  const { data: Bq, scales, zeros, config } = B;
+  const { groupSize, symmetric } = config;
+  const output = new Float32Array(M * N);
+  for (let m = 0;m < M; m++) {
+    for (let n = 0;n < N; n++) {
+      let sum = 0;
+      for (let k = 0;k < K; k++) {
+        const a = A[m * K + k];
+        const bIdx = k * N + n;
+        const byteIdx = Math.floor(bIdx / 2);
+        const isHigh = bIdx % 2 === 1;
+        let q;
+        if (isHigh) {
+          q = Bq[byteIdx] >> 4 & 15;
+        } else {
+          q = Bq[byteIdx] & 15;
+        }
+        const g = Math.floor(bIdx / groupSize);
+        const scale2 = scales[g];
+        let b;
+        if (symmetric) {
+          b = (q - 8) * scale2;
+        } else {
+          b = q * scale2 + zeros[g];
+        }
+        sum += a * b;
+      }
+      output[m * N + n] = sum;
+    }
+  }
+  return output;
+}
+function qmatmulInt8BlockCPU(A, B, M, K, N, blockSize = 32) {
+  if (B.config.bits !== 8) {
+    throw new Error("Expected INT8 weights");
+  }
+  const { data: Bq, scales, zeros, config } = B;
+  const { groupSize, symmetric } = config;
+  const output = new Float32Array(M * N);
+  for (let mb = 0;mb < M; mb += blockSize) {
+    const mEnd = Math.min(mb + blockSize, M);
+    for (let nb = 0;nb < N; nb += blockSize) {
+      const nEnd = Math.min(nb + blockSize, N);
+      for (let kb = 0;kb < K; kb += blockSize) {
+        const kEnd = Math.min(kb + blockSize, K);
+        for (let m = mb;m < mEnd; m++) {
+          for (let n = nb;n < nEnd; n++) {
+            let sum = output[m * N + n];
+            for (let k = kb;k < kEnd; k++) {
+              const a = A[m * K + k];
+              const bIdx = k * N + n;
+              const g = Math.floor(bIdx / groupSize);
+              const scale2 = scales[g];
+              let b;
+              if (symmetric) {
+                b = (Bq[bIdx] - 128) * scale2;
+              } else {
+                b = Bq[bIdx] * scale2 + zeros[g];
+              }
+              sum += a * b;
+            }
+            output[m * N + n] = sum;
+          }
+        }
+      }
+    }
+  }
+  return output;
+}
+function estimateQMatMulFlops(M, K, N) {
+  return 2 * M * K * N;
+}
+function estimateQMatMulBandwidth(M, K, N, bits, groupSize) {
+  const activationBytes = M * K * 4;
+  const weightElements = K * N;
+  const weightBytes = bits === 8 ? weightElements : Math.ceil(weightElements / 2);
+  const numGroups = Math.ceil(weightElements / groupSize);
+  const scaleBytes = numGroups * 4;
+  const outputBytes = M * N * 4;
+  return {
+    activationBytes,
+    weightBytes,
+    scaleBytes,
+    outputBytes,
+    totalBytes: activationBytes + weightBytes + scaleBytes + outputBytes
+  };
+}
+// src/attention/block-sparse/format.ts
+function buildBlockSparseCSR(seqLen, pattern, blockSize = 64) {
+  const numBlockRows = Math.ceil(seqLen / blockSize);
+  const numBlockCols = Math.ceil(seqLen / blockSize);
+  const nonZeroBlocks = [];
+  for (let br = 0;br < numBlockRows; br++) {
+    for (let bc = 0;bc < numBlockCols; bc++) {
+      if (isBlockNonZero(br, bc, blockSize, seqLen, pattern)) {
+        nonZeroBlocks.push({ row: br, col: bc });
+      }
+    }
+  }
+  const rowPtr = new Uint32Array(numBlockRows + 1);
+  const colIdx = new Uint32Array(nonZeroBlocks.length);
+  let idx = 0;
+  for (let br = 0;br < numBlockRows; br++) {
+    rowPtr[br] = idx;
+    for (const block of nonZeroBlocks) {
+      if (block.row === br) {
+        colIdx[idx++] = block.col;
+      }
+    }
+  }
+  rowPtr[numBlockRows] = idx;
+  return {
+    blockSize,
+    rowPtr,
+    colIdx,
+    numRows: seqLen,
+    numCols: seqLen,
+    numBlockRows,
+    numBlockCols,
+    nnzBlocks: nonZeroBlocks.length
+  };
+}
+function isBlockNonZero(blockRow, blockCol, blockSize, seqLen, pattern) {
+  const rowStart = blockRow * blockSize;
+  const rowEnd = Math.min(rowStart + blockSize, seqLen);
+  const colStart = blockCol * blockSize;
+  const colEnd = Math.min(colStart + blockSize, seqLen);
+  switch (pattern.type) {
+    case "dense":
+      return true;
+    case "causal":
+      return rowEnd > colStart;
+    case "sliding": {
+      const windowSize = pattern.windowSize;
+      return colStart < rowEnd && colEnd > Math.max(0, rowStart - windowSize);
+    }
+    case "global-local": {
+      const { globalTokens, localWindow } = pattern;
+      for (const gt of globalTokens) {
+        if (gt >= colStart && gt < colEnd)
+          return true;
+      }
+      return colStart < rowEnd && colEnd > Math.max(0, rowStart - localWindow);
+    }
+    case "custom":
+      for (let i = rowStart;i < rowEnd; i++) {
+        for (let j = colStart;j < colEnd; j++) {
+          if (pattern.mask[i]?.[j])
+            return true;
+        }
+      }
+      return false;
+    default:
+      return true;
+  }
+}
+function getSparsityRatio(csr) {
+  const totalBlocks = csr.numBlockRows * csr.numBlockCols;
+  return 1 - csr.nnzBlocks / totalBlocks;
+}
+function estimateMemorySavings(csr) {
+  const denseBytes = csr.numRows * csr.numCols * 4;
+  const sparseBytes = csr.nnzBlocks * csr.blockSize * csr.blockSize * 4 + (csr.numBlockRows + 1) * 4 + csr.nnzBlocks * 4;
+  return {
+    denseBytes,
+    sparseBytes,
+    savingsRatio: 1 - sparseBytes / denseBytes
+  };
+}
+
+// src/attention/flash-attention.ts
+var kernelCache8 = null;
+function getCache8(device) {
+  if (!kernelCache8) {
+    kernelCache8 = new KernelCache(device);
+  }
+  return kernelCache8;
+}
+async function flashAttention(device, q, k, v, config) {
+  const { numHeads, headDim, seqLen } = config;
+  const scale2 = config.scale ?? 1 / Math.sqrt(headDim);
+  const blockSize = config.blockSize ?? 64;
+  const pattern = config.pattern ?? { type: "causal" };
+  const sparseMask = buildBlockSparseCSR(seqLen, pattern, blockSize);
+  const cache = getCache8(device.device);
+  const pipeline = cache.getOrCreate(`flash_attn_${numHeads}_${headDim}_${seqLen}_${blockSize}`, () => compileFlashAttentionKernel(device.device, config, blockSize));
+  const output = Tensor.zeros(device, [seqLen, numHeads, headDim]);
+  const paramsData = new Float32Array([
+    seqLen,
+    numHeads,
+    headDim,
+    scale2,
+    blockSize,
+    sparseMask.numBlockRows,
+    0,
+    0
+  ]);
+  const paramsBuffer = device.device.createBuffer({
+    size: paramsData.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(paramsBuffer, 0, paramsData);
+  const rowPtrBuffer = device.device.createBuffer({
+    size: sparseMask.rowPtr.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.device.queue.writeBuffer(rowPtrBuffer, 0, new Uint32Array(sparseMask.rowPtr));
+  const colIdxBuffer = device.device.createBuffer({
+    size: Math.max(sparseMask.colIdx.byteLength, 4),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  if (sparseMask.colIdx.length > 0) {
+    device.device.queue.writeBuffer(colIdxBuffer, 0, new Uint32Array(sparseMask.colIdx));
+  }
+  const bindGroup = device.device.createBindGroup({
+    layout: pipeline.getBindGroupLayout(0),
+    entries: [
+      { binding: 0, resource: { buffer: q.buffer } },
+      { binding: 1, resource: { buffer: k.buffer } },
+      { binding: 2, resource: { buffer: v.buffer } },
+      { binding: 3, resource: { buffer: output.buffer } },
+      { binding: 4, resource: { buffer: paramsBuffer } },
+      { binding: 5, resource: { buffer: rowPtrBuffer } },
+      { binding: 6, resource: { buffer: colIdxBuffer } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  const workgroupsX = sparseMask.numBlockRows;
+  const workgroupsY = numHeads;
+  pass.dispatchWorkgroups(workgroupsX, workgroupsY);
+  pass.end();
+  device.submit([encoder.finish()]);
+  await device.device.queue.onSubmittedWorkDone();
+  paramsBuffer.destroy();
+  rowPtrBuffer.destroy();
+  colIdxBuffer.destroy();
+  return output;
+}
+function compileFlashAttentionKernel(device, config, blockSize) {
+  const { headDim } = config;
+  const wgsl = `
+// WebInfer FlashAttention Kernel
+// Implements online softmax with tiling for memory efficiency
+
+struct Params {
+  seqLen: u32,
+  numHeads: u32,
+  headDim: u32,
+  scale: f32,
+  blockSize: u32,
+  numBlockRows: u32,
+  _pad0: u32,
+  _pad1: u32,
+}
+
+@group(0) @binding(0) var<storage, read> Q: array<f32>;
+@group(0) @binding(1) var<storage, read> K: array<f32>;
+@group(0) @binding(2) var<storage, read> V: array<f32>;
+@group(0) @binding(3) var<storage, read_write> O: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+@group(0) @binding(5) var<storage, read> blockRowPtr: array<u32>;
+@group(0) @binding(6) var<storage, read> blockColIdx: array<u32>;
+
+// Shared memory for tiles
+var<workgroup> tileQ: array<f32, ${blockSize * headDim}>;
+var<workgroup> tileK: array<f32, ${blockSize * headDim}>;
+var<workgroup> tileV: array<f32, ${blockSize * headDim}>;
+var<workgroup> tileS: array<f32, ${blockSize * blockSize}>;
+
+// Online softmax state per row
+var<workgroup> rowMax: array<f32, ${blockSize}>;
+var<workgroup> rowSum: array<f32, ${blockSize}>;
+var<workgroup> rowOut: array<f32, ${blockSize * headDim}>;
+
+@compute @workgroup_size(${blockSize})
+fn main(
+  @builtin(workgroup_id) wgId: vec3<u32>,
+  @builtin(local_invocation_id) localId: vec3<u32>
+) {
+  let blockRowIdx = wgId.x;
+  let headIdx = wgId.y;
+  let tid = localId.x;
+
+  let blockSize = params.blockSize;
+  let headDim = params.headDim;
+  let seqLen = params.seqLen;
+  let scale = params.scale;
+
+  // Global row index
+  let globalRow = blockRowIdx * blockSize + tid;
+  let validRow = globalRow < seqLen;
+
+  // Initialize online softmax state
+  rowMax[tid] = -3.402823e+38f; // -inf
+  rowSum[tid] = 0.0f;
+
+  // Initialize output accumulator
+  for (var d = 0u; d < headDim; d = d + 1u) {
+    rowOut[tid * headDim + d] = 0.0f;
+  }
+
+  workgroupBarrier();
+
+  // Load Q tile for this block row
+  if (validRow) {
+    for (var d = 0u; d < headDim; d = d + 1u) {
+      let qIdx = globalRow * params.numHeads * headDim + headIdx * headDim + d;
+      tileQ[tid * headDim + d] = Q[qIdx];
+    }
+  }
+
+  workgroupBarrier();
+
+  // Iterate over non-zero blocks in this row (block-sparse)
+  let blockStart = blockRowPtr[blockRowIdx];
+  let blockEnd = blockRowPtr[blockRowIdx + 1u];
+
+  for (var b = blockStart; b < blockEnd; b = b + 1u) {
+    let blockColIdx_b = blockColIdx[b];
+    let globalCol = blockColIdx_b * blockSize + tid;
+    let validCol = globalCol < seqLen;
+
+    // Load K tile
+    if (validCol) {
+      for (var d = 0u; d < headDim; d = d + 1u) {
+        let kIdx = globalCol * params.numHeads * headDim + headIdx * headDim + d;
+        tileK[tid * headDim + d] = K[kIdx];
+      }
+    } else {
+      for (var d = 0u; d < headDim; d = d + 1u) {
+        tileK[tid * headDim + d] = 0.0f;
+      }
+    }
+
+    // Load V tile
+    if (validCol) {
+      for (var d = 0u; d < headDim; d = d + 1u) {
+        let vIdx = globalCol * params.numHeads * headDim + headIdx * headDim + d;
+        tileV[tid * headDim + d] = V[vIdx];
+      }
+    } else {
+      for (var d = 0u; d < headDim; d = d + 1u) {
+        tileV[tid * headDim + d] = 0.0f;
+      }
+    }
+
+    workgroupBarrier();
+
+    // Compute attention scores S = Q @ K^T * scale
+    // Each thread computes one row of scores
+    if (validRow) {
+      for (var j = 0u; j < blockSize; j = j + 1u) {
+        var score = 0.0f;
+        for (var d = 0u; d < headDim; d = d + 1u) {
+          score = score + tileQ[tid * headDim + d] * tileK[j * headDim + d];
+        }
+        score = score * scale;
+
+        // Apply causal mask
+        let colPos = blockColIdx_b * blockSize + j;
+        if (colPos > globalRow) {
+          score = -3.402823e+38f; // -inf for masked positions
+        }
+
+        tileS[tid * blockSize + j] = score;
+      }
+    }
+
+    workgroupBarrier();
+
+    // Online softmax update
+    if (validRow) {
+      // Find max in this tile
+      var tileMax = -3.402823e+38f;
+      for (var j = 0u; j < blockSize; j = j + 1u) {
+        tileMax = max(tileMax, tileS[tid * blockSize + j]);
+      }
+
+      // Update running max
+      let prevMax = rowMax[tid];
+      let newMax = max(prevMax, tileMax);
+      rowMax[tid] = newMax;
+
+      // Rescale previous sum and output
+      let rescale = exp(prevMax - newMax);
+      rowSum[tid] = rowSum[tid] * rescale;
+      for (var d = 0u; d < headDim; d = d + 1u) {
+        rowOut[tid * headDim + d] = rowOut[tid * headDim + d] * rescale;
+      }
+
+      // Compute softmax for this tile and accumulate
+      for (var j = 0u; j < blockSize; j = j + 1u) {
+        let p = exp(tileS[tid * blockSize + j] - newMax);
+        rowSum[tid] = rowSum[tid] + p;
+
+        // Accumulate output: O += p * V
+        for (var d = 0u; d < headDim; d = d + 1u) {
+          rowOut[tid * headDim + d] = rowOut[tid * headDim + d] + p * tileV[j * headDim + d];
+        }
+      }
+    }
+
+    workgroupBarrier();
+  }
+
+  // Final normalization and write output
+  if (validRow) {
+    let sumInv = 1.0f / rowSum[tid];
+    for (var d = 0u; d < headDim; d = d + 1u) {
+      let oIdx = globalRow * params.numHeads * headDim + headIdx * headDim + d;
+      O[oIdx] = rowOut[tid * headDim + d] * sumInv;
+    }
+  }
+}
+`;
+  const shaderModule = device.createShaderModule({ code: wgsl });
+  return device.createComputePipeline({
+    layout: "auto",
+    compute: {
+      module: shaderModule,
+      entryPoint: "main"
+    }
+  });
+}
+function attentionCPU(q, k, v, seqLen, numHeads, headDim, causal = true) {
+  const output = new Float32Array(seqLen * numHeads * headDim);
+  const scale2 = 1 / Math.sqrt(headDim);
+  for (let h = 0;h < numHeads; h++) {
+    for (let i = 0;i < seqLen; i++) {
+      const scores = new Float32Array(seqLen);
+      let maxScore = -Infinity;
+      for (let j = 0;j < seqLen; j++) {
+        if (causal && j > i) {
+          scores[j] = -Infinity;
+        } else {
+          let dot = 0;
+          for (let d = 0;d < headDim; d++) {
+            const qIdx = i * numHeads * headDim + h * headDim + d;
+            const kIdx = j * numHeads * headDim + h * headDim + d;
+            dot += q[qIdx] * k[kIdx];
+          }
+          scores[j] = dot * scale2;
+        }
+        maxScore = Math.max(maxScore, scores[j]);
+      }
+      let sumExp = 0;
+      for (let j = 0;j < seqLen; j++) {
+        scores[j] = Math.exp(scores[j] - maxScore);
+        sumExp += scores[j];
+      }
+      for (let j = 0;j < seqLen; j++) {
+        scores[j] = scores[j] / sumExp;
+      }
+      for (let d = 0;d < headDim; d++) {
+        let sum = 0;
+        for (let j = 0;j < seqLen; j++) {
+          const vIdx = j * numHeads * headDim + h * headDim + d;
+          sum += scores[j] * v[vIdx];
+        }
+        const oIdx = i * numHeads * headDim + h * headDim + d;
+        output[oIdx] = sum;
+      }
+    }
+  }
+  return output;
+}
+// src/attention/block-sparse/patterns/causal.ts
+function buildCausalMask(seqLen, blockSize = 64) {
+  const pattern = { type: "causal" };
+  return buildBlockSparseCSR(seqLen, pattern, blockSize);
+}
+function getCausalSparsity(seqLen) {
+  const total = seqLen * seqLen;
+  const nonZero = seqLen * (seqLen + 1) / 2;
+  return 1 - nonZero / total;
+}
+// src/attention/block-sparse/patterns/sliding.ts
+function buildSlidingWindowMask(seqLen, windowSize, blockSize = 64) {
+  const pattern = { type: "sliding", windowSize };
+  return buildBlockSparseCSR(seqLen, pattern, blockSize);
+}
+function getSlidingWindowSparsity(seqLen, windowSize) {
+  const total = seqLen * seqLen;
+  const triangularPart = windowSize * (windowSize + 1) / 2;
+  const remainingPositions = Math.max(0, seqLen - windowSize);
+  const windowPart = remainingPositions * (windowSize + 1);
+  const nonZero = triangularPart + windowPart;
+  return 1 - nonZero / total;
+}
+function buildCausalSlidingWindowMask(seqLen, windowSize, blockSize = 64) {
+  return buildSlidingWindowMask(seqLen, windowSize, blockSize);
+}
+// src/attention/scheduler.ts
+var TDR_LIMITS = {
+  chrome: 5000,
+  safari: 3000,
+  firefox: 8000,
+  default: 3000
+};
+
+class AttentionScheduler {
+  device;
+  tdrLimit;
+  constructor(device) {
+    this.device = device;
+    this.tdrLimit = this.detectTDRLimit();
+  }
+  detectTDRLimit() {
+    if (typeof navigator !== "undefined") {
+      const ua = navigator.userAgent.toLowerCase();
+      if (ua.includes("safari") && !ua.includes("chrome")) {
+        return TDR_LIMITS.safari;
+      } else if (ua.includes("firefox")) {
+        return TDR_LIMITS.firefox;
+      } else if (ua.includes("chrome") || ua.includes("edge")) {
+        return TDR_LIMITS.chrome;
+      }
+    }
+    return TDR_LIMITS.default;
+  }
+  estimateExecutionTime(seqLen, numHeads, headDim) {
+    const flops = 4 * seqLen * seqLen * numHeads * headDim;
+    let tflopsEstimate;
+    switch (this.device.info.vendor) {
+      case "apple":
+        tflopsEstimate = 10;
+        break;
+      case "nvidia":
+        tflopsEstimate = 20;
+        break;
+      case "amd":
+        tflopsEstimate = 15;
+        break;
+      case "intel":
+        tflopsEstimate = 8;
+        break;
+      default:
+        tflopsEstimate = 5;
+    }
+    return flops / (tflopsEstimate * 1000000000000) * 1000 * 2;
+  }
+  computeChunkPlan(seqLen, numHeads, headDim) {
+    const estimatedTime = this.estimateExecutionTime(seqLen, numHeads, headDim);
+    if (estimatedTime < this.tdrLimit * 0.7) {
+      return {
+        numChunks: 1,
+        chunkSize: seqLen,
+        estimatedTimeMs: estimatedTime
+      };
+    }
+    const targetTimePerChunk = this.tdrLimit * 0.5;
+    const numChunks = Math.ceil(estimatedTime / targetTimePerChunk);
+    const chunkSize = Math.ceil(seqLen / numChunks);
+    return {
+      numChunks,
+      chunkSize,
+      estimatedTimeMs: estimatedTime / numChunks
+    };
+  }
+  async yieldToMain() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  mightCauseTDR(seqLen, numHeads, headDim) {
+    const estimatedTime = this.estimateExecutionTime(seqLen, numHeads, headDim);
+    return estimatedTime > this.tdrLimit * 0.7;
+  }
+  getMaxSinglePassSeqLen(numHeads, headDim) {
+    let low = 1;
+    let high = 65536;
+    while (low < high) {
+      const mid = Math.floor((low + high + 1) / 2);
+      const time = this.estimateExecutionTime(mid, numHeads, headDim);
+      if (time <= this.tdrLimit * 0.7) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return low;
+  }
+}
+// src/attention/paged-kv/page-table.ts
+class PagedKVCache {
+  device;
+  config;
+  keyCache;
+  valueCache;
+  pageTable = new Map;
+  freePages = [];
+  nextSeqId = 0;
+  constructor(device, config) {
+    this.device = device;
+    this.config = config;
+    const bytesPerElement = config.dtype === "f16" ? 2 : 4;
+    const pageBytes = config.pageSize * config.numHeads * config.headDim * bytesPerElement;
+    const totalBytes = config.maxPages * pageBytes * config.numLayers;
+    this.keyCache = device.device.createBuffer({
+      size: totalBytes,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+    this.valueCache = device.device.createBuffer({
+      size: totalBytes,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+    });
+    for (let i = 0;i < config.maxPages; i++) {
+      this.freePages.push(i);
+    }
+  }
+  allocateSequence(initialLength = 0) {
+    const seqId = this.nextSeqId++;
+    const numPagesNeeded = Math.ceil(initialLength / this.config.pageSize);
+    const pages = [];
+    for (let i = 0;i < numPagesNeeded; i++) {
+      const page = this.allocatePage();
+      if (page === null) {
+        for (const p of pages) {
+          this.freePage(p);
+        }
+        throw new Error("Out of KV cache memory");
+      }
+      pages.push(page);
+    }
+    this.pageTable.set(seqId, {
+      seqId,
+      pages,
+      length: initialLength
+    });
+    return seqId;
+  }
+  extendSequence(seqId, numNewTokens) {
+    const entry = this.pageTable.get(seqId);
+    if (!entry) {
+      throw new Error(`Sequence ${seqId} not found`);
+    }
+    const newLength = entry.length + numNewTokens;
+    const currentPages = entry.pages.length;
+    const neededPages = Math.ceil(newLength / this.config.pageSize);
+    while (entry.pages.length < neededPages) {
+      const page = this.allocatePage();
+      if (page === null) {
+        throw new Error("Out of KV cache memory");
+      }
+      entry.pages.push(page);
+    }
+    entry.length = newLength;
+  }
+  freeSequence(seqId) {
+    const entry = this.pageTable.get(seqId);
+    if (!entry)
+      return;
+    for (const page of entry.pages) {
+      this.freePage(page);
+    }
+    this.pageTable.delete(seqId);
+  }
+  getSequencePages(seqId) {
+    return this.pageTable.get(seqId)?.pages ?? null;
+  }
+  getSequenceLength(seqId) {
+    return this.pageTable.get(seqId)?.length ?? 0;
+  }
+  getPageForPosition(seqId, position) {
+    const entry = this.pageTable.get(seqId);
+    if (!entry)
+      return null;
+    const pageIdx = Math.floor(position / this.config.pageSize);
+    return entry.pages[pageIdx] ?? null;
+  }
+  getOffsetInPage(position) {
+    return position % this.config.pageSize;
+  }
+  allocatePage() {
+    if (this.freePages.length === 0)
+      return null;
+    return this.freePages.pop();
+  }
+  freePage(page) {
+    this.freePages.push(page);
+  }
+  getStats() {
+    const bytesPerElement = this.config.dtype === "f16" ? 2 : 4;
+    const pageBytes = this.config.pageSize * this.config.numHeads * this.config.headDim * bytesPerElement;
+    const usedPages = this.config.maxPages - this.freePages.length;
+    return {
+      totalPages: this.config.maxPages,
+      usedPages,
+      freePages: this.freePages.length,
+      numSequences: this.pageTable.size,
+      memoryUsedBytes: usedPages * pageBytes * this.config.numLayers * 2,
+      memoryTotalBytes: this.config.maxPages * pageBytes * this.config.numLayers * 2
+    };
+  }
+  getBuffers() {
+    return {
+      keyCache: this.keyCache,
+      valueCache: this.valueCache
+    };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  dispose() {
+    this.keyCache.destroy();
+    this.valueCache.destroy();
+    this.pageTable.clear();
+    this.freePages = [];
+  }
+}
+// src/attention/paged-kv/block-manager.ts
+class BlockManager {
+  cache;
+  config;
+  priorities = new Map;
+  constructor(device, config) {
+    this.config = {
+      policy: "greedy",
+      reservedPages: 0,
+      ...config
+    };
+    this.cache = new PagedKVCache(device, config);
+  }
+  canAllocate(request) {
+    const stats = this.cache.getStats();
+    const neededPages = Math.ceil(request.numTokens / this.config.pageSize);
+    const availablePages = stats.freePages - (this.config.reservedPages ?? 0);
+    if (request.seqId !== undefined) {
+      const currentLength = this.cache.getSequenceLength(request.seqId);
+      const currentPages = Math.ceil(currentLength / this.config.pageSize);
+      const newLength = currentLength + request.numTokens;
+      const newPages = Math.ceil(newLength / this.config.pageSize);
+      return newPages - currentPages <= availablePages;
+    }
+    return neededPages <= availablePages;
+  }
+  allocate(request) {
+    if (request.seqId !== undefined) {
+      this.cache.extendSequence(request.seqId, request.numTokens);
+      if (request.priority !== undefined) {
+        this.priorities.set(request.seqId, request.priority);
+      }
+      return request.seqId;
+    }
+    const seqId = this.cache.allocateSequence(request.numTokens);
+    if (request.priority !== undefined) {
+      this.priorities.set(seqId, request.priority);
+    }
+    return seqId;
+  }
+  free(seqId) {
+    this.cache.freeSequence(seqId);
+    this.priorities.delete(seqId);
+  }
+  evict(neededPages) {
+    const evicted = [];
+    const stats = this.cache.getStats();
+    if (stats.freePages >= neededPages) {
+      return evicted;
+    }
+    const sequences = Array.from(this.priorities.entries()).sort((a, b) => a[1] - b[1]).map(([seqId]) => seqId);
+    for (const seqId of sequences) {
+      if (stats.freePages >= neededPages)
+        break;
+      const pages = this.cache.getSequencePages(seqId);
+      if (pages) {
+        this.free(seqId);
+        evicted.push(seqId);
+      }
+    }
+    return evicted;
+  }
+  getUtilization() {
+    const stats = this.cache.getStats();
+    return stats.usedPages / stats.totalPages;
+  }
+  getCache() {
+    return this.cache;
+  }
+  getStats() {
+    return this.cache.getStats();
+  }
+  dispose() {
+    this.cache.dispose();
+    this.priorities.clear();
+  }
+}
+
+class ContinuousBatchScheduler {
+  blockManager;
+  runningSequences = new Set;
+  waitingQueue = [];
+  constructor(blockManager) {
+    this.blockManager = blockManager;
+  }
+  addRequest(request) {
+    if (this.blockManager.canAllocate(request)) {
+      const seqId = this.blockManager.allocate(request);
+      this.runningSequences.add(seqId);
+    } else {
+      this.waitingQueue.push(request);
+    }
+  }
+  completeSequence(seqId) {
+    this.runningSequences.delete(seqId);
+    this.blockManager.free(seqId);
+    this.scheduleWaiting();
+  }
+  extendSequence(seqId, numNewTokens) {
+    if (!this.runningSequences.has(seqId)) {
+      return false;
+    }
+    const request = {
+      seqId,
+      numTokens: numNewTokens
+    };
+    if (this.blockManager.canAllocate(request)) {
+      this.blockManager.allocate(request);
+      return true;
+    }
+    return false;
+  }
+  scheduleWaiting() {
+    const stillWaiting = [];
+    for (const request of this.waitingQueue) {
+      if (this.blockManager.canAllocate(request)) {
+        const seqId = this.blockManager.allocate(request);
+        this.runningSequences.add(seqId);
+      } else {
+        stillWaiting.push(request);
+      }
+    }
+    this.waitingQueue = stillWaiting;
+  }
+  getRunningCount() {
+    return this.runningSequences.size;
+  }
+  getWaitingCount() {
+    return this.waitingQueue.length;
+  }
+}
+// src/sampling/top-k.ts
+async function topK(device, logits, k) {
+  if (logits.shape.length !== 1 && logits.shape.length !== 2) {
+    throw new Error("topK expects 1D or 2D tensor");
+  }
+  const is2D = logits.shape.length === 2;
+  const batchSize = is2D ? logits.shape[0] : 1;
+  const vocabSize = is2D ? logits.shape[1] : logits.shape[0];
+  if (k > vocabSize) {
+    throw new Error(`k (${k}) cannot be greater than vocab size (${vocabSize})`);
+  }
+  const logitsData = await logits.toArray();
+  const valuesData = new Float32Array(batchSize * k);
+  const indicesData = new Uint32Array(batchSize * k);
+  for (let b = 0;b < batchSize; b++) {
+    const offset = b * vocabSize;
+    const indices2 = new Array(vocabSize).fill(0).map((_, i) => i);
+    indices2.sort((a, b2) => logitsData[offset + b2] - logitsData[offset + a]);
+    for (let i = 0;i < k; i++) {
+      const idx = indices2[i];
+      valuesData[b * k + i] = logitsData[offset + idx];
+      indicesData[b * k + i] = idx;
+    }
+  }
+  const valuesShape = is2D ? [batchSize, k] : [k];
+  const indicesShape = is2D ? [batchSize, k] : [k];
+  const values = await Tensor.fromArray(device, valuesShape, valuesData);
+  const indices = new Tensor(device, indicesShape, "u32", indicesData);
+  return { values, indices };
+}
+function topKCPU(logits, k, vocabSize) {
+  const indices = new Array(vocabSize).fill(0).map((_, i) => i);
+  indices.sort((a, b) => logits[b] - logits[a]);
+  const values = new Float32Array(k);
+  const topIndices = new Uint32Array(k);
+  for (let i = 0;i < k; i++) {
+    const idx = indices[i];
+    values[i] = logits[idx];
+    topIndices[i] = idx;
+  }
+  return { values, indices: topIndices };
+}
+async function topKFilter(device, logits, k) {
+  const logitsData = await logits.toArray();
+  const vocabSize = logits.shape[logits.shape.length - 1];
+  const batchSize = logits.numel / vocabSize;
+  const filtered = new Float32Array(logits.numel);
+  for (let b = 0;b < batchSize; b++) {
+    const offset = b * vocabSize;
+    const values = logitsData.slice(offset, offset + vocabSize);
+    const sorted = Float32Array.from(values).sort((a, b2) => b2 - a);
+    const threshold = sorted[k - 1];
+    for (let i = 0;i < vocabSize; i++) {
+      if (logitsData[offset + i] >= threshold) {
+        filtered[offset + i] = logitsData[offset + i];
+      } else {
+        filtered[offset + i] = -Infinity;
+      }
+    }
+  }
+  return Tensor.fromArray(device, [...logits.shape], filtered);
+}
+// src/sampling/top-p.ts
+async function topPFilter(device, logits, p, temperature = 1) {
+  if (p <= 0 || p > 1) {
+    throw new Error("p must be in (0, 1]");
+  }
+  const logitsData = await logits.toArray();
+  const vocabSize = logits.shape[logits.shape.length - 1];
+  const batchSize = logits.numel / vocabSize;
+  const filtered = new Float32Array(logits.numel);
+  for (let b = 0;b < batchSize; b++) {
+    const offset = b * vocabSize;
+    const scaledLogits = new Float32Array(vocabSize);
+    for (let i = 0;i < vocabSize; i++) {
+      scaledLogits[i] = logitsData[offset + i] / temperature;
+    }
+    const maxLogit = Math.max(...scaledLogits);
+    const expLogits = scaledLogits.map((l) => Math.exp(l - maxLogit));
+    const sumExp = expLogits.reduce((a, b2) => a + b2, 0);
+    const probs = expLogits.map((e) => e / sumExp);
+    const indices = new Array(vocabSize).fill(0).map((_, i) => i);
+    indices.sort((a, b2) => probs[b2] - probs[a]);
+    let cumProb = 0;
+    const keepIndices = new Set;
+    for (const idx of indices) {
+      cumProb += probs[idx];
+      keepIndices.add(idx);
+      if (cumProb >= p)
+        break;
+    }
+    for (let i = 0;i < vocabSize; i++) {
+      if (keepIndices.has(i)) {
+        filtered[offset + i] = logitsData[offset + i];
+      } else {
+        filtered[offset + i] = -Infinity;
+      }
+    }
+  }
+  return Tensor.fromArray(device, [...logits.shape], filtered);
+}
+function topPFilterCPU(logits, p, temperature = 1) {
+  const vocabSize = logits.length;
+  const scaledLogits = new Float32Array(vocabSize);
+  for (let i = 0;i < vocabSize; i++) {
+    scaledLogits[i] = logits[i] / temperature;
+  }
+  const maxLogit = Math.max(...scaledLogits);
+  const expLogits = scaledLogits.map((l) => Math.exp(l - maxLogit));
+  const sumExp = expLogits.reduce((a, b) => a + b, 0);
+  const probs = expLogits.map((e) => e / sumExp);
+  const indices = new Array(vocabSize).fill(0).map((_, i) => i);
+  indices.sort((a, b) => probs[b] - probs[a]);
+  let cumProb = 0;
+  const keepIndices = new Set;
+  for (const idx of indices) {
+    cumProb += probs[idx];
+    keepIndices.add(idx);
+    if (cumProb >= p)
+      break;
+  }
+  const filtered = new Float32Array(vocabSize);
+  for (let i = 0;i < vocabSize; i++) {
+    filtered[i] = keepIndices.has(i) ? logits[i] : -Infinity;
+  }
+  return filtered;
+}
+// src/sampling/sampler.ts
+function softmax(logits) {
+  const maxLogit = Math.max(...logits);
+  const expLogits = logits.map((l) => Math.exp(l - maxLogit));
+  const sumExp = expLogits.reduce((a, b) => a + b, 0);
+  return expLogits.map((e) => e / sumExp);
+}
+function applyRepetitionPenalty(logits, previousTokens, penalty) {
+  if (penalty === 1)
+    return logits;
+  const result = new Float32Array(logits);
+  for (const token of previousTokens) {
+    if (token >= 0 && token < logits.length) {
+      if (result[token] > 0) {
+        result[token] = result[token] / penalty;
+      } else {
+        result[token] = result[token] * penalty;
+      }
+    }
+  }
+  return result;
+}
+function sampleFromProbs(probs, random = Math.random) {
+  const r = random();
+  let cumProb = 0;
+  for (let i = 0;i < probs.length; i++) {
+    cumProb += probs[i];
+    if (r < cumProb) {
+      return i;
+    }
+  }
+  return probs.length - 1;
+}
+function sampleGreedy(logits) {
+  let maxIdx = 0;
+  let maxVal = logits[0];
+  for (let i = 1;i < logits.length; i++) {
+    if (logits[i] > maxVal) {
+      maxVal = logits[i];
+      maxIdx = i;
+    }
+  }
+  return maxIdx;
+}
+async function sample(device, logits, config = {}, previousTokens = []) {
+  const {
+    temperature = 1,
+    topK: topK2 = 0,
+    topP = 1,
+    repetitionPenalty = 1
+  } = config;
+  let logitsData = await logits.toArray();
+  if (repetitionPenalty !== 1 && previousTokens.length > 0) {
+    logitsData = applyRepetitionPenalty(logitsData, previousTokens, repetitionPenalty);
+  }
+  if (temperature === 0 || temperature < 0.000001) {
+    return sampleGreedy(logitsData);
+  }
+  const scaledLogits = new Float32Array(logitsData.length);
+  for (let i = 0;i < logitsData.length; i++) {
+    scaledLogits[i] = logitsData[i] / temperature;
+  }
+  let filteredLogits = scaledLogits;
+  if (topK2 > 0 && topK2 < logitsData.length) {
+    const topKTensor = await Tensor.fromArray(device, [logitsData.length], scaledLogits);
+    const filtered = await topKFilter(device, topKTensor, topK2);
+    filteredLogits = new Float32Array(await filtered.toArray());
+    topKTensor.dispose();
+    filtered.dispose();
+  }
+  if (topP < 1) {
+    const topPTensor = await Tensor.fromArray(device, [filteredLogits.length], filteredLogits);
+    const filtered = await topPFilter(device, topPTensor, topP, 1);
+    filteredLogits = new Float32Array(await filtered.toArray());
+    topPTensor.dispose();
+    filtered.dispose();
+  }
+  const probs = softmax(filteredLogits);
+  return sampleFromProbs(probs);
+}
+function sampleCPU(logits, config = {}, previousTokens = []) {
+  const {
+    temperature = 1,
+    topK: topK2 = 0,
+    topP = 1,
+    repetitionPenalty = 1
+  } = config;
+  let processed = new Float32Array(logits);
+  if (repetitionPenalty !== 1 && previousTokens.length > 0) {
+    processed = new Float32Array(applyRepetitionPenalty(processed, previousTokens, repetitionPenalty));
+  }
+  if (temperature === 0 || temperature < 0.000001) {
+    return sampleGreedy(processed);
+  }
+  for (let i = 0;i < processed.length; i++) {
+    processed[i] = processed[i] / temperature;
+  }
+  if (topK2 > 0 && topK2 < processed.length) {
+    const sorted = new Float32Array(processed).sort((a, b) => b - a);
+    const threshold = sorted[topK2 - 1];
+    for (let i = 0;i < processed.length; i++) {
+      if (processed[i] < threshold) {
+        processed[i] = -Infinity;
+      }
+    }
+  }
+  if (topP < 1) {
+    const probs2 = softmax(processed);
+    const indices = new Array(processed.length).fill(0).map((_, i) => i);
+    indices.sort((a, b) => probs2[b] - probs2[a]);
+    let cumProb = 0;
+    const keepSet = new Set;
+    for (const idx of indices) {
+      cumProb += probs2[idx];
+      keepSet.add(idx);
+      if (cumProb >= topP)
+        break;
+    }
+    for (let i = 0;i < processed.length; i++) {
+      if (!keepSet.has(i)) {
+        processed[i] = -Infinity;
+      }
+    }
+  }
+  const probs = softmax(processed);
+  return sampleFromProbs(probs);
+}
+// src/model/types.ts
+var GGUFQuantType;
+((GGUFQuantType2) => {
+  GGUFQuantType2[GGUFQuantType2["F32"] = 0] = "F32";
+  GGUFQuantType2[GGUFQuantType2["F16"] = 1] = "F16";
+  GGUFQuantType2[GGUFQuantType2["Q4_0"] = 2] = "Q4_0";
+  GGUFQuantType2[GGUFQuantType2["Q4_1"] = 3] = "Q4_1";
+  GGUFQuantType2[GGUFQuantType2["Q5_0"] = 6] = "Q5_0";
+  GGUFQuantType2[GGUFQuantType2["Q5_1"] = 7] = "Q5_1";
+  GGUFQuantType2[GGUFQuantType2["Q8_0"] = 8] = "Q8_0";
+  GGUFQuantType2[GGUFQuantType2["Q8_1"] = 9] = "Q8_1";
+  GGUFQuantType2[GGUFQuantType2["Q2_K"] = 10] = "Q2_K";
+  GGUFQuantType2[GGUFQuantType2["Q3_K"] = 11] = "Q3_K";
+  GGUFQuantType2[GGUFQuantType2["Q4_K"] = 12] = "Q4_K";
+  GGUFQuantType2[GGUFQuantType2["Q5_K"] = 13] = "Q5_K";
+  GGUFQuantType2[GGUFQuantType2["Q6_K"] = 14] = "Q6_K";
+  GGUFQuantType2[GGUFQuantType2["Q8_K"] = 15] = "Q8_K";
+  GGUFQuantType2[GGUFQuantType2["IQ2_XXS"] = 16] = "IQ2_XXS";
+  GGUFQuantType2[GGUFQuantType2["IQ2_XS"] = 17] = "IQ2_XS";
+  GGUFQuantType2[GGUFQuantType2["IQ3_XXS"] = 18] = "IQ3_XXS";
+  GGUFQuantType2[GGUFQuantType2["IQ1_S"] = 19] = "IQ1_S";
+  GGUFQuantType2[GGUFQuantType2["IQ4_NL"] = 20] = "IQ4_NL";
+  GGUFQuantType2[GGUFQuantType2["IQ3_S"] = 21] = "IQ3_S";
+  GGUFQuantType2[GGUFQuantType2["IQ2_S"] = 22] = "IQ2_S";
+  GGUFQuantType2[GGUFQuantType2["IQ4_XS"] = 23] = "IQ4_XS";
+  GGUFQuantType2[GGUFQuantType2["I8"] = 24] = "I8";
+  GGUFQuantType2[GGUFQuantType2["I16"] = 25] = "I16";
+  GGUFQuantType2[GGUFQuantType2["I32"] = 26] = "I32";
+  GGUFQuantType2[GGUFQuantType2["I64"] = 27] = "I64";
+  GGUFQuantType2[GGUFQuantType2["F64"] = 28] = "F64";
+  GGUFQuantType2[GGUFQuantType2["BF16"] = 29] = "BF16";
+})(GGUFQuantType ||= {});
+var GGUFMetadataValueType;
+((GGUFMetadataValueType2) => {
+  GGUFMetadataValueType2[GGUFMetadataValueType2["UINT8"] = 0] = "UINT8";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["INT8"] = 1] = "INT8";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["UINT16"] = 2] = "UINT16";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["INT16"] = 3] = "INT16";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["UINT32"] = 4] = "UINT32";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["INT32"] = 5] = "INT32";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["FLOAT32"] = 6] = "FLOAT32";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["BOOL"] = 7] = "BOOL";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["STRING"] = 8] = "STRING";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["ARRAY"] = 9] = "ARRAY";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["UINT64"] = 10] = "UINT64";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["INT64"] = 11] = "INT64";
+  GGUFMetadataValueType2[GGUFMetadataValueType2["FLOAT64"] = 12] = "FLOAT64";
+})(GGUFMetadataValueType ||= {});
+var GGUF_QUANT_BLOCK_SIZE = {
+  [2 /* Q4_0 */]: 32,
+  [3 /* Q4_1 */]: 32,
+  [6 /* Q5_0 */]: 32,
+  [7 /* Q5_1 */]: 32,
+  [8 /* Q8_0 */]: 32,
+  [9 /* Q8_1 */]: 32,
+  [10 /* Q2_K */]: 256,
+  [11 /* Q3_K */]: 256,
+  [12 /* Q4_K */]: 256,
+  [13 /* Q5_K */]: 256,
+  [14 /* Q6_K */]: 256
+};
+var GGUF_QUANT_BYTES_PER_BLOCK = {
+  [0 /* F32 */]: 4,
+  [1 /* F16 */]: 2,
+  [2 /* Q4_0 */]: 18,
+  [3 /* Q4_1 */]: 20,
+  [6 /* Q5_0 */]: 22,
+  [7 /* Q5_1 */]: 24,
+  [8 /* Q8_0 */]: 34,
+  [9 /* Q8_1 */]: 36,
+  [10 /* Q2_K */]: 84,
+  [11 /* Q3_K */]: 110,
+  [12 /* Q4_K */]: 144,
+  [13 /* Q5_K */]: 176,
+  [14 /* Q6_K */]: 210
+};
+// src/model/safetensors.ts
+function parseSafetensorsHeader(buffer) {
+  const view = new DataView(buffer);
+  const headerSizeLow = view.getUint32(0, true);
+  const headerSizeHigh = view.getUint32(4, true);
+  if (headerSizeHigh > 0) {
+    throw new Error("Header size too large (exceeds 32-bit range)");
+  }
+  const headerSize = headerSizeLow;
+  const dataOffset = 8 + headerSize;
+  if (dataOffset > buffer.byteLength) {
+    throw new Error(`Invalid SafeTensors file: header size ${headerSize} exceeds file size`);
+  }
+  const headerBytes = new Uint8Array(buffer, 8, headerSize);
+  const headerJson = new TextDecoder("utf-8").decode(headerBytes);
+  let header;
+  try {
+    const parsed = JSON.parse(headerJson);
+    const { __metadata__, ...tensors } = parsed;
+    header = {
+      tensors,
+      __metadata__
+    };
+  } catch (e) {
+    throw new Error(`Failed to parse SafeTensors header JSON: ${e}`);
+  }
+  return { header, dataOffset };
+}
+function getSafetensorsTensorInfos(header, dataOffset) {
+  const tensorInfos = new Map;
+  for (const [name, entry] of Object.entries(header.tensors)) {
+    const [start, end] = entry.data_offsets;
+    const byteSize = end - start;
+    tensorInfos.set(name, {
+      name,
+      shape: entry.shape,
+      dtype: entry.dtype,
+      offset: dataOffset + start,
+      byteSize
+    });
+  }
+  return tensorInfos;
+}
+function loadSafetensorsTensor(buffer, info) {
+  const dtype = info.dtype;
+  const tensorData = new Uint8Array(buffer, info.offset, info.byteSize);
+  switch (dtype) {
+    case "F32": {
+      const float32 = new Float32Array(tensorData.buffer, tensorData.byteOffset, tensorData.byteLength / 4);
+      return new Float32Array(float32);
+    }
+    case "F16": {
+      const numel = info.shape.reduce((a, b) => a * b, 1);
+      const result = new Float32Array(numel);
+      const uint16View = new Uint16Array(tensorData.buffer, tensorData.byteOffset, numel);
+      for (let i = 0;i < numel; i++) {
+        result[i] = float16ToFloat32(uint16View[i]);
+      }
+      return result;
+    }
+    case "BF16": {
+      const numel = info.shape.reduce((a, b) => a * b, 1);
+      const result = new Float32Array(numel);
+      const uint16View = new Uint16Array(tensorData.buffer, tensorData.byteOffset, numel);
+      for (let i = 0;i < numel; i++) {
+        result[i] = bfloat16ToFloat32(uint16View[i]);
+      }
+      return result;
+    }
+    case "F64": {
+      const numel = info.shape.reduce((a, b) => a * b, 1);
+      const result = new Float32Array(numel);
+      const float64View = new Float64Array(tensorData.buffer, tensorData.byteOffset, numel);
+      for (let i = 0;i < numel; i++) {
+        result[i] = float64View[i];
+      }
+      return result;
+    }
+    case "I8":
+    case "U8":
+    case "I16":
+    case "I32":
+    case "I64":
+    case "BOOL": {
+      throw new Error(`Integer dtype ${dtype} not yet supported for loading`);
+    }
+    default:
+      throw new Error(`Unknown dtype: ${dtype}`);
+  }
+}
+function float16ToFloat32(h) {
+  const sign = (h & 32768) >> 15;
+  const exponent = (h & 31744) >> 10;
+  const fraction = h & 1023;
+  if (exponent === 0) {
+    if (fraction === 0) {
+      return sign === 1 ? -0 : 0;
+    }
+    return (sign === 1 ? -1 : 1) * Math.pow(2, -14) * (fraction / 1024);
+  } else if (exponent === 31) {
+    if (fraction === 0) {
+      return sign === 1 ? -Infinity : Infinity;
+    }
+    return NaN;
+  }
+  return (sign === 1 ? -1 : 1) * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+function bfloat16ToFloat32(bf16) {
+  const uint32 = bf16 << 16;
+  const buffer = new ArrayBuffer(4);
+  new DataView(buffer).setUint32(0, uint32, false);
+  return new DataView(buffer).getFloat32(0, false);
+}
+function extractMetadata(header) {
+  const meta = {
+    format: "safetensors",
+    extra: header.__metadata__
+  };
+  const tensorNames = Object.keys(header.tensors);
+  if (tensorNames.some((n) => n.includes("model.layers."))) {
+    meta.architecture = "llama";
+  } else if (tensorNames.some((n) => n.includes("transformer.h."))) {
+    meta.architecture = "gpt2";
+  }
+  for (const [name, entry] of Object.entries(header.tensors)) {
+    if (name.includes("embed_tokens") || name.includes("wte")) {
+      meta.vocabSize = entry.shape[0];
+      meta.embeddingLength = entry.shape[1];
+    }
+    if (name.includes("layers.0.self_attn.q_proj")) {
+      meta.embeddingLength = entry.shape[1];
+    }
+  }
+  const layerNums = tensorNames.map((n) => {
+    const match = n.match(/layers\.(\d+)\./);
+    return match ? parseInt(match[1], 10) : -1;
+  }).filter((n) => n >= 0);
+  if (layerNums.length > 0) {
+    meta.numLayers = Math.max(...layerNums) + 1;
+  }
+  return meta;
+}
+function loadSafetensors(buffer, options) {
+  const { header, dataOffset } = parseSafetensorsHeader(buffer);
+  const tensorInfos = getSafetensorsTensorInfos(header, dataOffset);
+  if (options?.tensorFilter) {
+    for (const name of tensorInfos.keys()) {
+      if (!options.tensorFilter(name)) {
+        tensorInfos.delete(name);
+      }
+    }
+  }
+  let totalBytes = 0;
+  for (const info of tensorInfos.values()) {
+    totalBytes += info.byteSize;
+  }
+  const metadata = extractMetadata(header);
+  return {
+    metadata,
+    tensorInfos,
+    totalBytes,
+    buffer,
+    dataOffset
+  };
+}
+async function loadSafetensorsFromUrl(url, options) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return loadSafetensors(buffer, options);
+}
+function isSafetensors(buffer) {
+  if (buffer.byteLength < 8)
+    return false;
+  try {
+    const view = new DataView(buffer);
+    const headerSize = view.getUint32(0, true);
+    const headerSizeHigh = view.getUint32(4, true);
+    if (headerSizeHigh !== 0 || headerSize > 100 * 1024 * 1024) {
+      return false;
+    }
+    if (8 + headerSize > buffer.byteLength) {
+      return false;
+    }
+    const headerBytes = new Uint8Array(buffer, 8, Math.min(headerSize, 100));
+    const headerStart = new TextDecoder("utf-8").decode(headerBytes);
+    return headerStart.trimStart().startsWith("{");
+  } catch {
+    return false;
+  }
+}
+// src/model/gguf.ts
+var GGUF_MAGIC = 1179993927;
+var GGUF_VERSION = 3;
+var DEFAULT_ALIGNMENT = 32;
+
+class GGUFReader {
+  view;
+  offset = 0;
+  textDecoder = new TextDecoder("utf-8");
+  constructor(buffer) {
+    this.view = new DataView(buffer);
+  }
+  get position() {
+    return this.offset;
+  }
+  set position(pos) {
+    this.offset = pos;
+  }
+  readUint8() {
+    const val = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return val;
+  }
+  readInt8() {
+    const val = this.view.getInt8(this.offset);
+    this.offset += 1;
+    return val;
+  }
+  readUint16() {
+    const val = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return val;
+  }
+  readInt16() {
+    const val = this.view.getInt16(this.offset, true);
+    this.offset += 2;
+    return val;
+  }
+  readUint32() {
+    const val = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return val;
+  }
+  readInt32() {
+    const val = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return val;
+  }
+  readUint64() {
+    const val = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return val;
+  }
+  readInt64() {
+    const val = this.view.getBigInt64(this.offset, true);
+    this.offset += 8;
+    return val;
+  }
+  readFloat32() {
+    const val = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return val;
+  }
+  readFloat64() {
+    const val = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return val;
+  }
+  readBool() {
+    return this.readUint8() !== 0;
+  }
+  readString() {
+    const length = Number(this.readUint64());
+    const bytes = new Uint8Array(this.view.buffer, this.offset, length);
+    this.offset += length;
+    return this.textDecoder.decode(bytes);
+  }
+  alignTo(alignment) {
+    const remainder = this.offset % alignment;
+    if (remainder !== 0) {
+      this.offset += alignment - remainder;
+    }
+  }
+}
+function parseGGUFHeader(reader) {
+  const magic = reader.readUint32();
+  if (magic !== GGUF_MAGIC) {
+    throw new Error(`Invalid GGUF magic: expected 0x${GGUF_MAGIC.toString(16)}, got 0x${magic.toString(16)}`);
+  }
+  const version = reader.readUint32();
+  if (version !== GGUF_VERSION) {
+    throw new Error(`Unsupported GGUF version: ${version} (expected ${GGUF_VERSION})`);
+  }
+  const nTensors = reader.readUint64();
+  const nKV = reader.readUint64();
+  return { magic, version, nTensors, nKV };
+}
+function parseMetadataValue(reader, valueType) {
+  switch (valueType) {
+    case 0 /* UINT8 */:
+      return reader.readUint8();
+    case 1 /* INT8 */:
+      return reader.readInt8();
+    case 2 /* UINT16 */:
+      return reader.readUint16();
+    case 3 /* INT16 */:
+      return reader.readInt16();
+    case 4 /* UINT32 */:
+      return reader.readUint32();
+    case 5 /* INT32 */:
+      return reader.readInt32();
+    case 6 /* FLOAT32 */:
+      return reader.readFloat32();
+    case 7 /* BOOL */:
+      return reader.readBool();
+    case 8 /* STRING */:
+      return reader.readString();
+    case 10 /* UINT64 */:
+      return reader.readUint64();
+    case 11 /* INT64 */:
+      return reader.readInt64();
+    case 12 /* FLOAT64 */:
+      return reader.readFloat64();
+    case 9 /* ARRAY */: {
+      const arrayType = reader.readUint32();
+      const arrayLen = Number(reader.readUint64());
+      const result = [];
+      for (let i = 0;i < arrayLen; i++) {
+        result.push(parseMetadataValue(reader, arrayType));
+      }
+      return result;
+    }
+    default:
+      throw new Error(`Unknown metadata value type: ${valueType}`);
+  }
+}
+function parseGGUFMetadata(reader, nKV) {
+  const metadata = new Map;
+  for (let i = 0n;i < nKV; i++) {
+    const key = reader.readString();
+    const valueType = reader.readUint32();
+    const value = parseMetadataValue(reader, valueType);
+    metadata.set(key, value);
+  }
+  return metadata;
+}
+function parseGGUFTensorInfos(reader, nTensors) {
+  const tensorInfos = [];
+  for (let i = 0n;i < nTensors; i++) {
+    const name = reader.readString();
+    const nDims = reader.readUint32();
+    const dimensions = [];
+    for (let d = 0;d < nDims; d++) {
+      dimensions.push(reader.readUint64());
+    }
+    const type = reader.readUint32();
+    const offset = reader.readUint64();
+    tensorInfos.push({ name, nDims, dimensions, type, offset });
+  }
+  return tensorInfos;
+}
+function calculateGGUFTensorBytes(type, shape) {
+  const numel = shape.reduce((a, b) => a * b, 1);
+  if (type === 0 /* F32 */) {
+    return numel * 4;
+  }
+  if (type === 1 /* F16 */ || type === 29 /* BF16 */) {
+    return numel * 2;
+  }
+  if (type === 24 /* I8 */) {
+    return numel;
+  }
+  if (type === 25 /* I16 */) {
+    return numel * 2;
+  }
+  if (type === 26 /* I32 */) {
+    return numel * 4;
+  }
+  if (type === 27 /* I64 */ || type === 28 /* F64 */) {
+    return numel * 8;
+  }
+  const blockSize = GGUF_QUANT_BLOCK_SIZE[type];
+  const bytesPerBlock = GGUF_QUANT_BYTES_PER_BLOCK[type];
+  if (blockSize === undefined || bytesPerBlock === undefined) {
+    throw new Error(`Unknown quantization type: ${type}`);
+  }
+  const numBlocks = Math.ceil(numel / blockSize);
+  return numBlocks * bytesPerBlock;
+}
+function convertTensorInfo(info, dataOffset) {
+  const shape = info.dimensions.map((d) => Number(d));
+  const byteSize = calculateGGUFTensorBytes(info.type, shape);
+  return {
+    name: info.name,
+    shape,
+    dtype: info.type,
+    offset: dataOffset + Number(info.offset),
+    byteSize
+  };
+}
+function extractGGUFMetadata(metadata) {
+  const meta = {
+    format: "gguf",
+    extra: Object.fromEntries(metadata)
+  };
+  meta.name = metadata.get("general.name");
+  meta.architecture = metadata.get("general.architecture");
+  const arch = meta.architecture || "";
+  meta.contextLength = metadata.get(`${arch}.context_length`);
+  meta.embeddingLength = metadata.get(`${arch}.embedding_length`);
+  meta.numLayers = metadata.get(`${arch}.block_count`);
+  meta.numHeads = metadata.get(`${arch}.attention.head_count`);
+  meta.numKVHeads = metadata.get(`${arch}.attention.head_count_kv`);
+  meta.vocabSize = metadata.get(`${arch}.vocab_size`);
+  meta.ropeFreqBase = metadata.get(`${arch}.rope.freq_base`);
+  if (meta.embeddingLength && meta.numHeads) {
+    meta.headDim = meta.embeddingLength / meta.numHeads;
+  }
+  return meta;
+}
+function loadGGUF(buffer, options) {
+  const reader = new GGUFReader(buffer);
+  const header = parseGGUFHeader(reader);
+  const rawMetadata = parseGGUFMetadata(reader, header.nKV);
+  const alignment = rawMetadata.get("general.alignment") || DEFAULT_ALIGNMENT;
+  const ggufTensorInfos = parseGGUFTensorInfos(reader, header.nTensors);
+  reader.alignTo(alignment);
+  const dataOffset = reader.position;
+  const tensorInfos = new Map;
+  let totalBytes = 0;
+  for (const info of ggufTensorInfos) {
+    if (options?.tensorFilter && !options.tensorFilter(info.name)) {
+      continue;
+    }
+    const converted = convertTensorInfo(info, dataOffset);
+    tensorInfos.set(info.name, converted);
+    totalBytes += converted.byteSize;
+  }
+  const metadata = extractGGUFMetadata(rawMetadata);
+  return {
+    metadata,
+    tensorInfos,
+    totalBytes,
+    buffer,
+    dataOffset
+  };
+}
+async function loadGGUFFromUrl(url, options) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+  }
+  const buffer = await response.arrayBuffer();
+  return loadGGUF(buffer, options);
+}
+function dequantizeQ4_0Block(data, offset) {
+  const result = new Float32Array(32);
+  const scaleU16 = data[offset + 1] << 8 | data[offset];
+  const scale2 = float16ToFloat322(scaleU16);
+  for (let i = 0;i < 16; i++) {
+    const byte = data[offset + 2 + i];
+    const v0 = (byte & 15) - 8;
+    const v1 = (byte >> 4 & 15) - 8;
+    result[i * 2] = v0 * scale2;
+    result[i * 2 + 1] = v1 * scale2;
+  }
+  return result;
+}
+function dequantizeQ8_0Block(data, offset) {
+  const result = new Float32Array(32);
+  const scaleU16 = data[offset + 1] << 8 | data[offset];
+  const scale2 = float16ToFloat322(scaleU16);
+  for (let i = 0;i < 32; i++) {
+    const v = data[offset + 2 + i];
+    const signed = v > 127 ? v - 256 : v;
+    result[i] = signed * scale2;
+  }
+  return result;
+}
+function loadGGUFTensor(buffer, info) {
+  const type = info.dtype;
+  const data = new Uint8Array(buffer, info.offset, info.byteSize);
+  const numel = info.shape.reduce((a, b) => a * b, 1);
+  switch (type) {
+    case 0 /* F32 */: {
+      return new Float32Array(buffer, info.offset, numel);
+    }
+    case 1 /* F16 */: {
+      const result = new Float32Array(numel);
+      const u16 = new Uint16Array(buffer, info.offset, numel);
+      for (let i = 0;i < numel; i++) {
+        result[i] = float16ToFloat322(u16[i]);
+      }
+      return result;
+    }
+    case 2 /* Q4_0 */: {
+      const blockSize = 32;
+      const bytesPerBlock = 18;
+      const numBlocks = Math.ceil(numel / blockSize);
+      const result = new Float32Array(numel);
+      for (let b = 0;b < numBlocks; b++) {
+        const blockData = dequantizeQ4_0Block(data, b * bytesPerBlock);
+        const outOffset = b * blockSize;
+        const copyLen = Math.min(blockSize, numel - outOffset);
+        result.set(blockData.subarray(0, copyLen), outOffset);
+      }
+      return result;
+    }
+    case 8 /* Q8_0 */: {
+      const blockSize = 32;
+      const bytesPerBlock = 34;
+      const numBlocks = Math.ceil(numel / blockSize);
+      const result = new Float32Array(numel);
+      for (let b = 0;b < numBlocks; b++) {
+        const blockData = dequantizeQ8_0Block(data, b * bytesPerBlock);
+        const outOffset = b * blockSize;
+        const copyLen = Math.min(blockSize, numel - outOffset);
+        result.set(blockData.subarray(0, copyLen), outOffset);
+      }
+      return result;
+    }
+    default:
+      throw new Error(`Quantization type ${GGUFQuantType[type]} not yet supported for dequantization`);
+  }
+}
+function isGGUF(buffer) {
+  if (buffer.byteLength < 24)
+    return false;
+  try {
+    const view = new DataView(buffer);
+    const magic = view.getUint32(0, true);
+    return magic === GGUF_MAGIC;
+  } catch {
+    return false;
+  }
+}
+function float16ToFloat322(h) {
+  const sign = (h & 32768) >> 15;
+  const exponent = (h & 31744) >> 10;
+  const fraction = h & 1023;
+  if (exponent === 0) {
+    if (fraction === 0) {
+      return sign === 1 ? -0 : 0;
+    }
+    return (sign === 1 ? -1 : 1) * Math.pow(2, -14) * (fraction / 1024);
+  } else if (exponent === 31) {
+    if (fraction === 0) {
+      return sign === 1 ? -Infinity : Infinity;
+    }
+    return NaN;
+  }
+  return (sign === 1 ? -1 : 1) * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+// src/model/index.ts
+async function loadModel(source, options) {
+  let buffer;
+  if (typeof source === "string") {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch model: ${response.statusText}`);
+    }
+    buffer = await response.arrayBuffer();
+  } else {
+    buffer = source;
+  }
+  if (isGGUF(buffer)) {
+    return loadGGUF(buffer, options);
+  } else if (isSafetensors(buffer)) {
+    return loadSafetensors(buffer, options);
+  } else {
+    throw new Error("Unknown model format. Expected SafeTensors or GGUF.");
+  }
+}
+// src/inference/types.ts
+var DEFAULT_GENERATION_CONFIG = {
+  maxTokens: 256,
+  temperature: 1,
+  topK: 0,
+  topP: 1,
+  repetitionPenalty: 1,
+  eosTokenId: 2,
+  padTokenId: 0,
+  bosTokenId: 1,
+  stream: false
+};
+function normalizeGenerationConfig(config) {
+  const normalized = {
+    maxTokens: config.maxTokens ?? DEFAULT_GENERATION_CONFIG.maxTokens,
+    temperature: config.temperature ?? DEFAULT_GENERATION_CONFIG.temperature,
+    topK: config.topK ?? DEFAULT_GENERATION_CONFIG.topK,
+    topP: config.topP ?? DEFAULT_GENERATION_CONFIG.topP,
+    repetitionPenalty: config.repetitionPenalty ?? DEFAULT_GENERATION_CONFIG.repetitionPenalty,
+    eosTokenId: config.eosTokenId ?? DEFAULT_GENERATION_CONFIG.eosTokenId,
+    padTokenId: config.padTokenId ?? DEFAULT_GENERATION_CONFIG.padTokenId,
+    bosTokenId: config.bosTokenId ?? DEFAULT_GENERATION_CONFIG.bosTokenId,
+    stream: config.stream ?? DEFAULT_GENERATION_CONFIG.stream,
+    stopSequences: config.stopSequences,
+    seed: config.seed
+  };
+  if (normalized.maxTokens < 1) {
+    throw new Error("maxTokens must be >= 1");
+  }
+  if (normalized.temperature !== undefined && normalized.temperature < 0) {
+    throw new Error("temperature must be >= 0");
+  }
+  if (normalized.topK !== undefined && normalized.topK < 0) {
+    throw new Error("topK must be >= 0");
+  }
+  if (normalized.topP !== undefined && (normalized.topP < 0 || normalized.topP > 1)) {
+    throw new Error("topP must be between 0 and 1");
+  }
+  if (normalized.repetitionPenalty !== undefined && normalized.repetitionPenalty < 1) {
+    throw new Error("repetitionPenalty must be >= 1");
+  }
+  return normalized;
+}
+// src/inference/engine.ts
+var DEFAULT_INFERENCE_CONFIG = {
+  maxBatchSize: 1,
+  maxSeqLen: 2048,
+  useKVCache: true,
+  memoryLimit: 0,
+  enableProfiling: false
+};
+
+class InferenceEngine {
+  device;
+  config;
+  modelConfig = null;
+  weights = null;
+  loadedModel = null;
+  kvCache = null;
+  ropeFreqsCos = null;
+  ropeFreqsSin = null;
+  constructor(device, config) {
+    this.device = device;
+    this.config = { ...DEFAULT_INFERENCE_CONFIG, ...config };
+  }
+  async loadModel(model, modelConfig) {
+    this.loadedModel = model;
+    this.modelConfig = modelConfig;
+    this.weights = await this.extractWeights(model, modelConfig);
+    const headDim = modelConfig.headDim ?? modelConfig.hiddenSize / modelConfig.numHeads;
+    const ropeFreqBase = modelConfig.ropeFreqBase ?? 1e4;
+    const { cos, sin } = computeRoPEFrequencies({
+      dim: headDim,
+      maxSeqLen: this.config.maxSeqLen,
+      base: ropeFreqBase
+    });
+    this.ropeFreqsCos = cos;
+    this.ropeFreqsSin = sin;
+    if (this.config.useKVCache) {
+      this.initKVCache(modelConfig);
+    }
+  }
+  async extractWeights(model, config) {
+    const loadTensor = (name) => {
+      const info = model.tensorInfos.get(name);
+      if (!info) {
+        throw new Error(`Tensor not found: ${name}`);
+      }
+      if (model.metadata.format === "safetensors") {
+        return loadSafetensorsTensor(model.buffer, info);
+      } else {
+        return loadGGUFTensor(model.buffer, info);
+      }
+    };
+    const tryLoad = (names) => {
+      for (const name of names) {
+        if (model.tensorInfos.has(name)) {
+          return loadTensor(name);
+        }
+      }
+      throw new Error(`None of these tensors found: ${names.join(", ")}`);
+    };
+    const embedTokens = tryLoad([
+      "model.embed_tokens.weight",
+      "transformer.wte.weight",
+      "embedding.weight"
+    ]);
+    const layers = [];
+    for (let i = 0;i < config.numLayers; i++) {
+      const prefix = `model.layers.${i}`;
+      const gptPrefix = `transformer.h.${i}`;
+      const layerWeights = {
+        attention: {
+          qProj: tryLoad([`${prefix}.self_attn.q_proj.weight`, `${gptPrefix}.attn.q_proj.weight`]),
+          kProj: tryLoad([`${prefix}.self_attn.k_proj.weight`, `${gptPrefix}.attn.k_proj.weight`]),
+          vProj: tryLoad([`${prefix}.self_attn.v_proj.weight`, `${gptPrefix}.attn.v_proj.weight`]),
+          oProj: tryLoad([`${prefix}.self_attn.o_proj.weight`, `${gptPrefix}.attn.o_proj.weight`])
+        },
+        ffn: {
+          gate: model.tensorInfos.has(`${prefix}.mlp.gate_proj.weight`) ? loadTensor(`${prefix}.mlp.gate_proj.weight`) : undefined,
+          up: tryLoad([`${prefix}.mlp.up_proj.weight`, `${gptPrefix}.mlp.up_proj.weight`]),
+          down: tryLoad([`${prefix}.mlp.down_proj.weight`, `${gptPrefix}.mlp.down_proj.weight`])
+        },
+        inputNorm: tryLoad([
+          `${prefix}.input_layernorm.weight`,
+          `${gptPrefix}.ln_1.weight`
+        ]),
+        postAttentionNorm: tryLoad([
+          `${prefix}.post_attention_layernorm.weight`,
+          `${gptPrefix}.ln_2.weight`
+        ])
+      };
+      layers.push(layerWeights);
+    }
+    const finalNorm = tryLoad([
+      "model.norm.weight",
+      "transformer.ln_f.weight"
+    ]);
+    const lmHead = tryLoad([
+      "lm_head.weight",
+      "transformer.lm_head.weight"
+    ]);
+    return { embedTokens, layers, finalNorm, lmHead };
+  }
+  initKVCache(config) {
+    const headDim = config.headDim ?? config.hiddenSize / config.numHeads;
+    const numKVHeads = config.numKVHeads ?? config.numHeads;
+    const cacheSize = this.config.maxSeqLen * numKVHeads * headDim;
+    this.kvCache = {
+      keys: [],
+      values: [],
+      seqLen: 0
+    };
+    for (let i = 0;i < config.numLayers; i++) {
+      this.kvCache.keys.push(new Float32Array(cacheSize));
+      this.kvCache.values.push(new Float32Array(cacheSize));
+    }
+  }
+  resetKVCache() {
+    if (this.kvCache) {
+      this.kvCache.seqLen = 0;
+      for (let i = 0;i < this.kvCache.keys.length; i++) {
+        this.kvCache.keys[i].fill(0);
+        this.kvCache.values[i].fill(0);
+      }
+    }
+  }
+  forward(inputIds, startPos = 0) {
+    if (!this.weights || !this.modelConfig) {
+      throw new Error("Model not loaded. Call loadModel() first.");
+    }
+    const config = this.modelConfig;
+    const weights = this.weights;
+    const seqLen = inputIds.length;
+    const headDim = config.headDim ?? config.hiddenSize / config.numHeads;
+    const numKVHeads = config.numKVHeads ?? config.numHeads;
+    const eps = config.rmsNormEps ?? 0.00001;
+    const inputIdsArray = Array.from(inputIds);
+    let hidden = embeddingCPU(weights.embedTokens, inputIdsArray, config.hiddenSize);
+    for (let layer = 0;layer < config.numLayers; layer++) {
+      const lw = weights.layers[layer];
+      const normedHidden = rmsNormCPU(hidden, lw.inputNorm, [seqLen, config.hiddenSize], eps);
+      hidden = this.attentionForward(normedHidden, lw, layer, startPos, seqLen, headDim, numKVHeads, hidden);
+      const normedHidden2 = rmsNormCPU(hidden, lw.postAttentionNorm, [seqLen, config.hiddenSize], eps);
+      hidden = this.ffnForward(normedHidden2, lw, hidden);
+    }
+    hidden = rmsNormCPU(hidden, weights.finalNorm, [seqLen, config.hiddenSize], eps);
+    const lastTokenHidden = hidden.slice((seqLen - 1) * config.hiddenSize, seqLen * config.hiddenSize);
+    const logits = matmulCPU(lastTokenHidden, weights.lmHead, 1, config.vocabSize, config.hiddenSize);
+    return {
+      logits,
+      logitsShape: [1, config.vocabSize]
+    };
+  }
+  attentionForward(x, lw, layerIdx, startPos, seqLen, headDim, numKVHeads, residual) {
+    const config = this.modelConfig;
+    const hiddenSize = config.hiddenSize;
+    const numHeads = config.numHeads;
+    let q = matmulCPU(x, lw.attention.qProj, seqLen, numHeads * headDim, hiddenSize);
+    let k = matmulCPU(x, lw.attention.kProj, seqLen, numKVHeads * headDim, hiddenSize);
+    let v = matmulCPU(x, lw.attention.vProj, seqLen, numKVHeads * headDim, hiddenSize);
+    if (this.ropeFreqsCos && this.ropeFreqsSin) {
+      for (let pos = 0;pos < seqLen; pos++) {
+        const actualPos = startPos + pos;
+        for (let h = 0;h < numHeads; h++) {
+          const qOffset = pos * numHeads * headDim + h * headDim;
+          this.applyRoPE(q, qOffset, actualPos, headDim);
+        }
+        for (let h = 0;h < numKVHeads; h++) {
+          const kOffset = pos * numKVHeads * headDim + h * headDim;
+          this.applyRoPE(k, kOffset, actualPos, headDim);
+        }
+      }
+    }
+    if (this.kvCache) {
+      const kvSize = numKVHeads * headDim;
+      for (let pos = 0;pos < seqLen; pos++) {
+        const cachePos = (startPos + pos) * kvSize;
+        this.kvCache.keys[layerIdx].set(k.subarray(pos * kvSize, (pos + 1) * kvSize), cachePos);
+        this.kvCache.values[layerIdx].set(v.subarray(pos * kvSize, (pos + 1) * kvSize), cachePos);
+      }
+      this.kvCache.seqLen = startPos + seqLen;
+      const totalLen = startPos + seqLen;
+      k = this.kvCache.keys[layerIdx].slice(0, totalLen * kvSize);
+      v = this.kvCache.values[layerIdx].slice(0, totalLen * kvSize);
+    }
+    const scale2 = 1 / Math.sqrt(headDim);
+    const totalKVLen = this.kvCache ? this.kvCache.seqLen : seqLen;
+    const attnOutput = new Float32Array(seqLen * numHeads * headDim);
+    for (let pos = 0;pos < seqLen; pos++) {
+      for (let h = 0;h < numHeads; h++) {
+        const kvHead = Math.floor(h * numKVHeads / numHeads);
+        const scores = new Float32Array(totalKVLen);
+        for (let kPos = 0;kPos < totalKVLen; kPos++) {
+          if (kPos > startPos + pos) {
+            scores[kPos] = -Infinity;
+            continue;
+          }
+          let score = 0;
+          for (let d = 0;d < headDim; d++) {
+            const qIdx = pos * numHeads * headDim + h * headDim + d;
+            const kIdx = kPos * numKVHeads * headDim + kvHead * headDim + d;
+            score += q[qIdx] * k[kIdx];
+          }
+          scores[kPos] = score * scale2;
+        }
+        const probs = softmaxCPU(scores, [totalKVLen]);
+        for (let d = 0;d < headDim; d++) {
+          let val = 0;
+          for (let vPos = 0;vPos < totalKVLen; vPos++) {
+            const vIdx = vPos * numKVHeads * headDim + kvHead * headDim + d;
+            val += probs[vPos] * v[vIdx];
+          }
+          const outIdx = pos * numHeads * headDim + h * headDim + d;
+          attnOutput[outIdx] = val;
+        }
+      }
+    }
+    const projected = matmulCPU(attnOutput, lw.attention.oProj, seqLen, hiddenSize, numHeads * headDim);
+    return addCPU(residual, projected);
+  }
+  applyRoPE(x, offset, position, headDim) {
+    for (let i = 0;i < headDim / 2; i++) {
+      const freqIdx = position * (headDim / 2) + i;
+      const cos = this.ropeFreqsCos[freqIdx];
+      const sin = this.ropeFreqsSin[freqIdx];
+      const x0 = x[offset + i];
+      const x1 = x[offset + headDim / 2 + i];
+      x[offset + i] = x0 * cos - x1 * sin;
+      x[offset + headDim / 2 + i] = x0 * sin + x1 * cos;
+    }
+  }
+  ffnForward(x, lw, residual) {
+    const config = this.modelConfig;
+    const seqLen = x.length / config.hiddenSize;
+    const up = matmulCPU(x, lw.ffn.up, seqLen, config.intermediateSize, config.hiddenSize);
+    let gateOut;
+    if (lw.ffn.gate) {
+      gateOut = matmulCPU(x, lw.ffn.gate, seqLen, config.intermediateSize, config.hiddenSize);
+      const upSilu = siluCPU(up);
+      gateOut = mulCPU(gateOut, upSilu);
+    } else {
+      gateOut = siluCPU(up);
+    }
+    const down = matmulCPU(gateOut, lw.ffn.down, seqLen, config.hiddenSize, config.intermediateSize);
+    return addCPU(residual, down);
+  }
+  getModelConfig() {
+    return this.modelConfig;
+  }
+  isLoaded() {
+    return this.weights !== null;
+  }
+  dispose() {
+    this.weights = null;
+    this.loadedModel = null;
+    this.kvCache = null;
+    this.ropeFreqsCos = null;
+    this.ropeFreqsSin = null;
+  }
+}
+// src/inference/generate.ts
+function sampleNextToken(logits, config, generatedTokens) {
+  return sampleCPU(logits, {
+    temperature: config.temperature,
+    topK: config.topK,
+    topP: config.topP,
+    repetitionPenalty: config.repetitionPenalty
+  }, generatedTokens || []);
+}
+function checkStopSequences(generatedTokens, stopSequences) {
+  if (!stopSequences || stopSequences.length === 0) {
+    return false;
+  }
+  for (const stopSeq of stopSequences) {
+    if (generatedTokens.length >= stopSeq.length) {
+      const tail = generatedTokens.slice(-stopSeq.length);
+      if (tail.every((t, i) => t === stopSeq[i])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function generate(engine, promptTokens, config = {}) {
+  const normalizedConfig = normalizeGenerationConfig(config);
+  const startTime = performance.now();
+  engine.resetKVCache();
+  const prompt = promptTokens instanceof Uint32Array ? promptTokens : new Uint32Array(promptTokens);
+  let result = engine.forward(prompt, 0);
+  const generatedTokens = [];
+  let finishReason = "length";
+  let currentPos = prompt.length;
+  for (let i = 0;i < normalizedConfig.maxTokens; i++) {
+    const nextToken = sampleNextToken(result.logits, normalizedConfig, generatedTokens);
+    generatedTokens.push(nextToken);
+    if (nextToken === normalizedConfig.eosTokenId) {
+      finishReason = "eos";
+      break;
+    }
+    if (checkStopSequences(generatedTokens, normalizedConfig.stopSequences)) {
+      finishReason = "stop";
+      break;
+    }
+    const inputToken = new Uint32Array([nextToken]);
+    result = engine.forward(inputToken, currentPos);
+    currentPos += 1;
+  }
+  const endTime = performance.now();
+  const totalTimeMs = endTime - startTime;
+  return {
+    tokens: generatedTokens,
+    finishReason,
+    promptTokens: prompt.length,
+    generatedTokens: generatedTokens.length,
+    totalTimeMs,
+    tokensPerSecond: generatedTokens.length / totalTimeMs * 1000
+  };
+}
+async function* generateStream(engine, promptTokens, config = {}) {
+  const normalizedConfig = normalizeGenerationConfig(config);
+  engine.resetKVCache();
+  const prompt = promptTokens instanceof Uint32Array ? promptTokens : new Uint32Array(promptTokens);
+  let result = engine.forward(prompt, 0);
+  const generatedTokens = [];
+  let currentPos = prompt.length;
+  for (let i = 0;i < normalizedConfig.maxTokens; i++) {
+    const nextToken = sampleNextToken(result.logits, normalizedConfig, generatedTokens);
+    generatedTokens.push(nextToken);
+    let finishReason;
+    let isLast = false;
+    if (nextToken === normalizedConfig.eosTokenId) {
+      finishReason = "eos";
+      isLast = true;
+    } else if (checkStopSequences(generatedTokens, normalizedConfig.stopSequences)) {
+      finishReason = "stop";
+      isLast = true;
+    } else if (i === normalizedConfig.maxTokens - 1) {
+      finishReason = "length";
+      isLast = true;
+    }
+    yield {
+      tokenId: nextToken,
+      index: i,
+      isLast,
+      finishReason
+    };
+    if (isLast) {
+      break;
+    }
+    const inputToken = new Uint32Array([nextToken]);
+    result = engine.forward(inputToken, currentPos);
+    currentPos += 1;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+function greedyDecode(engine, promptTokens, maxTokens, eosTokenId = 2) {
+  engine.resetKVCache();
+  const prompt = promptTokens instanceof Uint32Array ? promptTokens : new Uint32Array(promptTokens);
+  let result = engine.forward(prompt, 0);
+  const generatedTokens = [];
+  let currentPos = prompt.length;
+  for (let i = 0;i < maxTokens; i++) {
+    let maxIdx = 0;
+    let maxVal = result.logits[0];
+    for (let j = 1;j < result.logits.length; j++) {
+      if (result.logits[j] > maxVal) {
+        maxVal = result.logits[j];
+        maxIdx = j;
+      }
+    }
+    generatedTokens.push(maxIdx);
+    if (maxIdx === eosTokenId) {
+      break;
+    }
+    const inputToken = new Uint32Array([maxIdx]);
+    result = engine.forward(inputToken, currentPos);
+    currentPos += 1;
+  }
+  return generatedTokens;
+}
+export {
+  transposeCPU,
+  transpose2DCPU,
+  transpose2D,
+  topPFilterCPU,
+  topPFilter,
+  topKFilter,
+  topKCPU,
+  topK,
+  softmaxGPU,
+  softmaxCPU,
+  softmax,
+  siluCPU,
+  silu,
+  sigmoidCPU,
+  scaleCPU,
+  scale,
+  sampleNextToken,
+  sampleGreedy,
+  sampleFromProbs,
+  sampleCPU,
+  sample,
+  ropeCPU,
+  rope,
+  rmsNormCPU,
+  rmsNorm,
+  reshapeCPU,
+  reluCPU,
+  relu,
+  quantizeToInt8,
+  quantizeToInt4,
+  quantizationError,
+  qmatmulInt8CPU,
+  qmatmulInt8BlockCPU,
+  qmatmulInt4CPU,
+  permuteCPU,
+  parseSafetensorsHeader,
+  parseGGUFHeader,
+  normalizeGenerationConfig,
+  mulCPU,
+  mul,
+  matmulCPU,
+  matmul,
+  logSoftmaxCPU,
+  loadSafetensorsFromUrl,
+  loadSafetensors,
+  loadModel,
+  loadGGUFTensor,
+  loadGGUFFromUrl,
+  loadGGUF,
+  layerNormCPU,
+  layerNorm,
+  isSafetensors,
+  isGGUF,
+  greedyDecode,
+  getSparsityRatio,
+  getSlidingWindowSparsity,
+  getMemorySavings,
+  getMatMulCacheStats,
+  getCausalSparsity,
+  generateStream,
+  generate,
+  geluExactCPU,
+  geluCPU,
+  gelu,
+  fmaCPU,
+  flashAttention,
+  estimateQMatMulFlops,
+  estimateQMatMulBandwidth,
+  estimateMemorySavings,
+  embeddingCPU,
+  embedding,
+  dequantizeInt8,
+  dequantizeInt4,
+  computeRoPEFrequencies,
+  buildSlidingWindowMask,
+  buildCausalSlidingWindowMask,
+  buildCausalMask,
+  buildBlockSparseCSR,
+  batchedEmbeddingCPU,
+  attentionCPU,
+  applyRepetitionPenalty,
+  addScalarCPU,
+  addCPU,
+  add,
+  WebInferDevice,
+  WGSLCompiler,
+  Tensor,
+  PagedKVCache,
+  KernelCache,
+  InferenceEngine,
+  GGUFQuantType,
+  GGUFMetadataValueType,
+  DEFAULT_GENERATION_CONFIG,
+  ContinuousBatchScheduler,
+  BufferPool,
+  BlockManager,
+  AttentionScheduler
+};