@simulatte/doppler 0.1.8 → 0.2.0

package/src/inference/pipelines/text/logits/index.d.ts

@@ -1,62 +0,0 @@
-/**
- * Logits computation - final layer norm and LM head projection.
- *
- * This module handles the final steps of inference:
- * - Apply final RMS norm to hidden states
- * - Project to vocabulary size via LM head
- * - Handle tied embeddings (transposeB for HuggingFace format)
- * - CPU fallback for non-GPU execution
- *
- * @module inference/pipelines/text/logits
- */
-
-import type { ProbeConfigSchema } from '../../../../config/schema/index.js';
-import type { LogitsConfig, LogitsWeights, LogitsDebugFlags } from './types.js';
-
-// Re-export all types
-export type { LogitsConfig, LogitsWeights, LogitsDebugFlags } from './types.js';
-
-// Re-export CPU functions
-export { rmsNormCPU, matmulCPU, applySoftcapping, f16ToF32, f16BufferToF32 } from './cpu.js';
-
-// Re-export GPU functions
-export { computeLogitsGPU, recordLogitsGPU, computeChunkedLogitsGPU, resolveCpuWeightDims, resolveLmHeadChunkRows, extractLmHeadChunk, writeChunkLogits } from './gpu.js';
-
-// Re-export utilities
-export { extractLastPositionLogits, finalizeLogits } from './utils.js';
-
-export interface ComputeLogitsOptions {
-  lastPositionOnly?: boolean;
-}
-
-/**
- * Compute logits from hidden states.
- *
- * This function:
- * 1. Applies final RMS normalization
- * 2. Projects to vocabulary via LM head matrix multiplication
- * 3. Handles tied embeddings (uses transposeB for HF format)
- * 4. Falls back to CPU if GPU unavailable
- *
- * @param hiddenStates - Hidden states from transformer [numTokens, hiddenSize]
- * @param numTokens - Number of tokens (required for GPU buffer input)
- * @param weights - Final norm and LM head weights
- * @param config - Model configuration for logits
- * @param useGPU - Whether to use GPU
- * @param debugFlags - Debug flags to prevent repeated logging
- * @param getNormWeightBuffer - Helper to get norm weight buffer (from pipeline)
- * @param debugCheckBuffer - Helper for debug buffer checking (from pipeline)
- * @returns Logits tensor [numTokens, vocabSize]
- */
-export function computeLogits(
-  hiddenStates: GPUBuffer | Float32Array,
-  numTokens: number,
-  weights: LogitsWeights,
-  config: LogitsConfig,
-  useGPU: boolean,
-  debugFlags?: LogitsDebugFlags,
-  getNormWeightBuffer?: (weight: GPUBuffer | Float32Array | ArrayBuffer, label: string) => GPUBuffer,
-  debugCheckBuffer?: (buffer: GPUBuffer, label: string, numTokens: number, expectedDim?: number) => Promise<void>,
-  debugProbes?: ProbeConfigSchema[] | null,
-  options?: ComputeLogitsOptions
-): Promise<Float32Array>;

package/src/inference/pipelines/text/logits/index.js

@@ -1,306 +0,0 @@
-
-
-// Re-export CPU functions
-export { rmsNormCPU, matmulCPU, applySoftcapping, f16ToF32, f16BufferToF32 } from './cpu.js';
-
-// Re-export GPU functions
-export { computeLogitsGPU, recordLogitsGPU, computeChunkedLogitsGPU, resolveCpuWeightDims, resolveLmHeadChunkRows, extractLmHeadChunk, writeChunkLogits } from './gpu.js';
-
-// Re-export utilities
-export { extractLastPositionLogits, finalizeLogits, readBufferWithCleanup } from './utils.js';
-
-// Imports for computeLogits orchestrator
-import { getDevice } from '../../../../gpu/device.js';
-import { acquireBuffer, releaseBuffer, readBuffer } from '../../../../memory/buffer-pool.js';
-import { runMatmul, runRMSNorm, castF16ToF32 } from '../../../../gpu/kernel-selector.js';
-import { createTensor } from '../../../../gpu/tensor.js';
-import { isWeightBuffer, isCpuWeightBuffer, getWeightDtype } from '../../../../gpu/weight-buffer.js';
-import { kernelTrace, traceStep } from '../kernel-trace.js';
-import { log, trace, isTraceEnabled } from '../../../../debug/index.js';
-import { runProbes } from '../probes.js';
-import { rmsNormCPU, matmulCPU, f16BufferToF32 } from './cpu.js';
-import { resolveCpuWeightDims, computeChunkedLogitsGPU } from './gpu.js';
-import { finalizeLogits, readBufferWithCleanup } from './utils.js';
-import { getRuntimeConfig } from '../../../../config/runtime.js';
-import { selectRuleValue } from '../../../../rules/rule-registry.js';
-
-function shouldForceStableF32Logits(config, inputDtype) {
-  // Small Gemma-family checkpoints can overflow in pure F16 logits path after RMSNorm offset.
-  return inputDtype === 'f16'
-    && config.rmsNormWeightOffset === true
-    && Number.isFinite(config.hiddenSize)
-    && config.hiddenSize <= 768;
-}
-
-
-export async function computeLogits(
-  hiddenStates,
-  numTokens,
-  weights,
-  config,
-  useGPU,
-  debugFlags = {},
-  getNormWeightBuffer,
-  debugCheckBuffer,
-  debugProbes,
-  options = null
-) {
-  if (isTraceEnabled('logits')) {
-    trace.logits(`LOGITS_ENTRY: numTokens=${numTokens}, useGPU=${useGPU}`);
-  }
-  const {
-    hiddenSize,
-    vocabSize,
-    rmsNormEps,
-    useTiedEmbeddings,
-    embeddingVocabSize,
-    largeWeights,
-    activationDtype: activationDtypeOverride,
-  } = config;
-  const activationDtype = activationDtypeOverride ?? getRuntimeConfig().inference.compute.activationDtype;
-  const { finalNorm, lmHead } = weights;
-  const device = getDevice();
-
-  if (!finalNorm || !lmHead) {
-    log.warn('Pipeline', 'Final norm or LM head not loaded, returning zeros');
-    return new Float32Array(vocabSize);
-  }
-
-  const requestedVocabSize = useTiedEmbeddings && embeddingVocabSize
-    ? embeddingVocabSize
-    : vocabSize;
-  let matmulVocabSize = requestedVocabSize;
-  
-  let cpuWeightVocabSize = null;
-  
-  let cpuWeightLayout = null;
-
-  if (isCpuWeightBuffer(lmHead)) {
-    const dims = resolveCpuWeightDims(lmHead);
-    cpuWeightVocabSize = dims.vocabSize;
-    cpuWeightLayout = lmHead.layout;
-    if (!cpuWeightLayout) {
-      throw new Error('LM head CPU weight is missing layout metadata.');
-    }
-    if (dims.hiddenSize !== hiddenSize) {
-      log.warn('Logits', `LM head hiddenSize mismatch: weight=${dims.hiddenSize}, expected=${hiddenSize}`);
-    }
-    if (matmulVocabSize > dims.vocabSize) {
-      log.warn('Logits', `LM head vocabSize smaller than requested: weight=${dims.vocabSize}, requested=${matmulVocabSize}. Clamping.`);
-      matmulVocabSize = dims.vocabSize;
-    }
-  }
-
-  // Check if input is GPU buffer
-  const inputIsGPU = hiddenStates instanceof GPUBuffer;
-
-  // CPU fallback path
-  if (isTraceEnabled('logits')) {
-    trace.logits(`LOGITS_PATH: device=${!!device}, useGPU=${useGPU}, taking ${(!device || !useGPU) ? 'CPU' : 'GPU'} path`);
-  }
-  if (!device || !useGPU) {
-    
-    let cpuHiddenStates;
-    if (inputIsGPU) {
-      const bytesPerElement = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: activationDtype });
-      const data = await readBuffer(hiddenStates, numTokens * hiddenSize * bytesPerElement);
-      const decodeDtype = selectRuleValue('shared', 'dtype', 'f16OrF32FromDtype', { dtype: activationDtype });
-      cpuHiddenStates = decodeDtype === 'f16'
-        ? f16BufferToF32(data)
-        : new Float32Array(data);
-    } else {
-      cpuHiddenStates =  (hiddenStates);
-    }
-    const normed = rmsNormCPU(
-      cpuHiddenStates,
-      (finalNorm),
-      rmsNormEps,
-      config.rmsNormWeightOffset
-    );
-    const rawLogits = isCpuWeightBuffer(lmHead)
-      ? matmulCPU(
-        normed,
-        lmHead.data,
-        numTokens,
-        matmulVocabSize,
-        hiddenSize,
-        cpuWeightLayout,
-        cpuWeightLayout === 'column' ? cpuWeightVocabSize : null
-      )
-      : matmulCPU(normed, (lmHead), numTokens, matmulVocabSize, hiddenSize);
-    return finalizeLogits(rawLogits, numTokens, matmulVocabSize, vocabSize, config, debugProbes);
-  }
-
-  // GPU path
-  // 1. Get or create input buffer
-  
-  let inputBuffer;
-  let inputBufferOwned = false;
-  if (inputIsGPU) {
-    inputBuffer =  (hiddenStates);
-  } else {
-    inputBuffer = acquireBuffer((hiddenStates).byteLength, undefined, 'logits_input');
-    device.queue.writeBuffer(inputBuffer, 0, (hiddenStates));
-    inputBufferOwned = true;
-  }
-  const inputDtype = inputIsGPU ? activationDtype : 'f32';
-  await runProbes('pre_final_norm', inputBuffer, {
-    numTokens,
-    hiddenSize,
-    probes: debugProbes,
-    dtype: inputDtype,
-  });
-
-  // 2. Apply final RMSNorm
-  
-  let normWeightBuffer;
-  if (getNormWeightBuffer) {
-    normWeightBuffer = getNormWeightBuffer(finalNorm, 'final_norm_w');
-  } else if (finalNorm instanceof GPUBuffer) {
-    normWeightBuffer = finalNorm;
-  } else {
-    normWeightBuffer = acquireBuffer((finalNorm).byteLength, undefined, 'final_norm_w');
-    device.queue.writeBuffer(normWeightBuffer, 0, (finalNorm));
-  }
-
-  // Debug: Check hidden state before final norm
-  if (!debugFlags.finalNormDebugDone && debugCheckBuffer) {
-    debugFlags.finalNormDebugDone = true;
-    await debugCheckBuffer(inputBuffer, 'Before final norm', numTokens, hiddenSize);
-    await debugCheckBuffer(normWeightBuffer, 'Final norm weights', 1, hiddenSize);
-  }
-
-  // Wrap input buffer as Tensor for RMSNorm
-  const inputTensor = createTensor(inputBuffer, inputDtype, [numTokens, hiddenSize], 'logits_input');
-  const forceStableF32Logits = shouldForceStableF32Logits(config, inputDtype);
-  let normInputTensor = inputTensor;
-  let normInputBufferOwned = false;
-  if (forceStableF32Logits) {
-    normInputTensor = await castF16ToF32(inputTensor);
-    normInputBufferOwned = true;
-  }
-  const normedTensor = await runRMSNorm(normInputTensor, normWeightBuffer, rmsNormEps, {
-    batchSize: numTokens,
-    hiddenSize,
-    rmsNormWeightOffset: config.rmsNormWeightOffset,
-  });
-  if (normInputBufferOwned) {
-    releaseBuffer(normInputTensor.buffer);
-  }
-  await runProbes('final_norm', normedTensor.buffer, {
-    numTokens,
-    hiddenSize,
-    probes: debugProbes,
-    dtype: normedTensor.dtype,
-  });
-
-  // Trace final norm output
-  if (kernelTrace.enabled) {
-    await traceStep('rmsnorm', 'final_norm', -1, normedTensor.buffer, [numTokens, hiddenSize]);
-  }
-
-  // Debug: Check hidden state after final norm
-  if (!debugFlags.afterFinalNormDebugDone && debugCheckBuffer) {
-    debugFlags.afterFinalNormDebugDone = true;
-    await debugCheckBuffer(normedTensor.buffer, 'After final norm', numTokens, hiddenSize);
-  }
-
-  if (isCpuWeightBuffer(lmHead)) {
-    if (cpuWeightVocabSize == null) {
-      throw new Error('LM head CPU weight is missing vocabSize metadata.');
-    }
-    const rawLogits = await computeChunkedLogitsGPU(
-      normedTensor,
-      lmHead,
-      numTokens,
-      hiddenSize,
-      matmulVocabSize,
-      cpuWeightVocabSize,
-      debugProbes,
-      largeWeights,
-      config.kernelPath ?? null
-    );
-
-    if (inputBufferOwned) releaseBuffer(inputBuffer);
-    releaseBuffer(normedTensor.buffer);
-    if (!getNormWeightBuffer && !(finalNorm instanceof GPUBuffer)) releaseBuffer(normWeightBuffer);
-
-    return finalizeLogits(rawLogits, numTokens, matmulVocabSize, vocabSize, config, debugProbes);
-  }
-
-  // 3. Project to vocab via LM head
-  
-  let lmHeadBuffer;
-  let lmHeadBufferOwned = false;
-  if (lmHead instanceof GPUBuffer) {
-    lmHeadBuffer = lmHead;
-  } else if (isWeightBuffer(lmHead)) {
-    lmHeadBuffer = lmHead;
-  } else {
-    const rawBuffer = acquireBuffer((lmHead).byteLength, undefined, 'lm_head_w');
-    device.queue.writeBuffer(rawBuffer, 0, (lmHead));
-    lmHeadBuffer = rawBuffer;
-    lmHeadBufferOwned = true;
-  }
-
-  // Debug: Log buffer info for lm_head matmul
-  const lmHeadGPU = isWeightBuffer(lmHeadBuffer) ? lmHeadBuffer.buffer : lmHeadBuffer;
-  const lmHeadDtype = getWeightDtype(lmHeadBuffer);  // dtype from WeightBuffer metadata
-  const normedDtype = normedTensor.dtype;
-  if (isTraceEnabled('logits')) {
-    trace.logits(`LM_HEAD_MATMUL: M=${numTokens}, N=${matmulVocabSize}, K=${hiddenSize}, lmHeadDtype=${lmHeadDtype}, normedDtype=${normedDtype}, size=${lmHeadGPU.size}, bufLabel=${lmHeadGPU.label}`);
-  }
-
-  const lastPositionOnly = options?.lastPositionOnly === true && numTokens > 1;
-  const matmulRows = lastPositionOnly ? 1 : numTokens;
-  const matmulPhaseOverride = lastPositionOnly ? 'prefill' : null;
-  let matmulInputTensor = normedTensor;
-  let matmulInputOwned = false;
-  if (lastPositionOnly) {
-    const inputBytes = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: normedTensor.dtype });
-    const rowSize = hiddenSize * inputBytes;
-    const rowOffset = (numTokens - 1) * rowSize;
-    const lastInputBuffer = acquireBuffer(rowSize, undefined, 'logits_input_last');
-    const encoder = device.createCommandEncoder();
-    encoder.copyBufferToBuffer(normedTensor.buffer, rowOffset, lastInputBuffer, 0, rowSize);
-    device.queue.submit([encoder.finish()]);
-    matmulInputTensor = createTensor(lastInputBuffer, normedTensor.dtype, [1, hiddenSize], 'logits_input_last');
-    matmulInputOwned = true;
-  }
-
-  // HuggingFace models store lm_head as [vocabSize, hiddenSize], so transposeB=true
-  const logitsTensor = await runMatmul(matmulInputTensor, lmHeadBuffer, matmulRows, matmulVocabSize, hiddenSize, {
-    transposeB: 'auto',
-    role: 'lm_head',
-    phaseOverride: matmulPhaseOverride,
-    kernelPath: config.kernelPath ?? null,
-  });
-  await runProbes('logits', logitsTensor.buffer, {
-    numTokens: matmulRows,
-    hiddenSize: matmulVocabSize,
-    probes: debugProbes,
-    dtype: logitsTensor.dtype,
-  });
-
-  // Trace lm_head output
-  if (kernelTrace.enabled) {
-    await traceStep('matmul', 'lm_head', -1, logitsTensor.buffer, [matmulRows, matmulVocabSize]);
-  }
-
-  // 4. Read back logits
-  const logitsBytes = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: logitsTensor.dtype });
-  const logitsReadSize = matmulRows * matmulVocabSize * logitsBytes;
-  const logitsData = await readBufferWithCleanup(logitsTensor.buffer, logitsReadSize, () => {
-    if (inputBufferOwned) releaseBuffer(inputBuffer);
-    releaseBuffer(normedTensor.buffer);
-    if (matmulInputOwned) releaseBuffer(matmulInputTensor.buffer);
-    releaseBuffer(logitsTensor.buffer);
-    if (!getNormWeightBuffer && !(finalNorm instanceof GPUBuffer)) releaseBuffer(normWeightBuffer);
-    if (lmHeadBufferOwned) releaseBuffer(lmHeadGPU);
-  });
-
-  const rawLogits = logitsTensor.dtype === 'f16'
-    ? f16BufferToF32(logitsData)
-    : new Float32Array(logitsData);
-  return finalizeLogits(rawLogits, matmulRows, matmulVocabSize, vocabSize, config, debugProbes);
-}

package/src/inference/pipelines/text/logits/types.d.ts

@@ -1,46 +0,0 @@
-/**
- * Type definitions for logits computation.
- *
- * Contains interfaces for configuration, weights, and debug flags
- * used throughout the logits computation pipeline.
- *
- * @module inference/pipelines/text/logits/types
- */
-
-import type { LargeWeightConfigSchema, KernelPathSchema } from '../../../../config/schema/index.js';
-import type { WeightBuffer, CpuWeightBuffer } from '../../../../gpu/weight-buffer.js';
-
-/**
- * Configuration for logits computation.
- */
-export interface LogitsConfig {
-  hiddenSize: number;
-  vocabSize: number;
-  rmsNormEps: number;
-  useTiedEmbeddings: boolean;
-  embeddingVocabSize: number | null;
-  finalLogitSoftcapping: number | null;  // Gemma 2: 30.0 - applies tanh(x/cap)*cap
-  largeWeights?: LargeWeightConfigSchema;
-  /** Dtype for hidden state activations */
-  activationDtype?: 'f16' | 'f32';
-  /** Explicit kernel-path context for variant selection. */
-  kernelPath?: KernelPathSchema | null;
-  /** Gemma 2 RMS scaling: (1+w)*x */
-  rmsNormWeightOffset?: boolean;
-}
-
-/**
- * Weights required for logits computation.
- */
-export interface LogitsWeights {
-  finalNorm: GPUBuffer | Float32Array;
-  lmHead: GPUBuffer | Float32Array | WeightBuffer | CpuWeightBuffer;
-}
-
-/**
- * Debug flags for logits computation.
- */
-export interface LogitsDebugFlags {
-  finalNormDebugDone?: boolean;
-  afterFinalNormDebugDone?: boolean;
-}

package/src/inference/pipelines/text/logits/types.js

@@ -1,4 +0,0 @@
-
-
-// Runtime placeholder for the type-only logits/types module.
-// All public types are declared in types.d.ts.

package/src/inference/pipelines/text/logits/utils.d.ts

@@ -1,56 +0,0 @@
-/**
- * Utility functions for logits computation.
- *
- * Provides helper functions for extracting logits and finalizing results.
- *
- * @module inference/pipelines/text/logits/utils
- */
-
-import type { ProbeConfigSchema } from '../../../../config/schema/index.js';
-import type { LogitsConfig } from './types.js';
-
-/**
- * Extract logits for only the last position.
- *
- * Used after prefill to get logits for sampling the first generated token.
- *
- * @param logits - Full logits tensor [numTokens, vocabSize]
- * @param numTokens - Number of tokens
- * @param vocabSize - Vocabulary size
- * @returns Logits for last position [vocabSize]
- */
-export function extractLastPositionLogits(
-  logits: Float32Array,
-  numTokens: number,
-  vocabSize: number
-): Float32Array;
-
-export function readBufferWithCleanup(
-  buffer: GPUBuffer,
-  byteLength: number,
-  cleanup?: (() => void) | null,
-  reader?: ((buffer: GPUBuffer, byteLength: number) => Promise<ArrayBuffer>) | null
-): Promise<ArrayBuffer>;
-
-/**
- * Finalize logits by applying padding and softcapping.
- *
- * Handles vocabulary size mismatch (padding with -Infinity)
- * and applies final logit softcapping if configured.
- *
- * @param rawLogits - Raw logits from matmul
- * @param numTokens - Number of tokens
- * @param matmulVocabSize - Vocab size used in matmul
- * @param vocabSize - Target vocab size
- * @param config - Logits configuration
- * @param debugProbes - Optional debug probes
- * @returns Finalized logits
- */
-export function finalizeLogits(
-  rawLogits: Float32Array,
-  numTokens: number,
-  matmulVocabSize: number,
-  vocabSize: number,
-  config: LogitsConfig,
-  debugProbes?: ProbeConfigSchema[] | null
-): Promise<Float32Array>;

package/src/inference/pipelines/text/logits/utils.js

@@ -1,68 +0,0 @@
-
-
-import { readBuffer } from '../../../../memory/buffer-pool.js';
-import { runProbes } from '../probes.js';
-import { applySoftcapping } from './cpu.js';
-
-
-export function extractLastPositionLogits(
-  logits,
-  numTokens,
-  vocabSize
-) {
-  const lastPosLogits = new Float32Array(vocabSize);
-  const lastPosOffset = (numTokens - 1) * vocabSize;
-
-  for (let i = 0; i < vocabSize; i++) {
-    lastPosLogits[i] = logits[lastPosOffset + i];
-  }
-
-  return lastPosLogits;
-}
-
-export async function readBufferWithCleanup(buffer, byteLength, cleanup, reader = readBuffer) {
-  try {
-    return await reader(buffer, byteLength);
-  } finally {
-    cleanup?.();
-  }
-}
-
-
-export async function finalizeLogits(
-  rawLogits,
-  numTokens,
-  matmulVocabSize,
-  vocabSize,
-  config,
-  debugProbes
-) {
-  let logits = rawLogits;
-
-  if (matmulVocabSize < vocabSize) {
-    const paddedLogits = new Float32Array(numTokens * vocabSize);
-    for (let t = 0; t < numTokens; t++) {
-      const srcOffset = t * matmulVocabSize;
-      const dstOffset = t * vocabSize;
-      for (let i = 0; i < matmulVocabSize; i++) {
-        paddedLogits[dstOffset + i] = rawLogits[srcOffset + i];
-      }
-      for (let i = matmulVocabSize; i < vocabSize; i++) {
-        paddedLogits[dstOffset + i] = -Infinity;
-      }
-    }
-    logits = paddedLogits;
-  }
-
-  if (config.finalLogitSoftcapping != null) {
-    applySoftcapping(logits, config.finalLogitSoftcapping);
-  }
-
-  await runProbes('logits_final', logits, {
-    numTokens,
-    hiddenSize: vocabSize,
-    probes: debugProbes,
-  });
-
-  return logits;
-}

package/src/inference/pipelines/text/logits.d.ts

@@ -1,27 +0,0 @@
-/**
- * Logits computation - final layer norm and LM head projection.
- *
- * Public aggregation entrypoint.
- * Implementation is split into focused modules under logits/.
- *
- * @module inference/pipelines/text/logits
- */
-
-export {
-  // Types
-  type LogitsConfig,
-  type LogitsWeights,
-  type LogitsDebugFlags,
-  // CPU functions
-  rmsNormCPU,
-  matmulCPU,
-  applySoftcapping,
-  // GPU functions
-  computeLogitsGPU,
-  recordLogitsGPU,
-  // Utilities
-  extractLastPositionLogits,
-  finalizeLogits,
-  // Main orchestrator
-  computeLogits,
-} from './logits/index.js';

package/src/inference/pipelines/text/logits.js

@@ -1,16 +0,0 @@
-
-
-export {
-  // CPU functions
-  rmsNormCPU,
-  matmulCPU,
-  applySoftcapping,
-  // GPU functions
-  computeLogitsGPU,
-  recordLogitsGPU,
-  // Utilities
-  extractLastPositionLogits,
-  finalizeLogits,
-  // Main orchestrator
-  computeLogits,
-} from './logits/index.js';

package/src/inference/pipelines/text/lora-apply.d.ts

@@ -1,28 +0,0 @@
-/**
- * LoRA application helpers for matmul outputs.
- *
- * @module inference/pipelines/text/lora-apply
- */
-
-import type { CommandRecorder } from '../../../gpu/command-recorder.js';
-import type { Tensor } from '../../../gpu/tensor.js';
-import type { WeightBuffer } from '../../../gpu/weight-buffer.js';
-import type { LoRAModuleWeights } from './lora.js';
-import type { MaybeGPUBuffer } from './types.js';
-import type { KernelPathSchema } from '../../../config/schema/index.js';
-
-interface LoRADims {
-  M: number;
-  N: number;
-  K: number;
-}
-
-export function applyLoRA(
-  input: Tensor,
-  baseOutput: Tensor,
-  lora: LoRAModuleWeights,
-  dims: LoRADims,
-  getWeightBuffer: (weight: MaybeGPUBuffer, label: string) => GPUBuffer | WeightBuffer,
-  recorder?: CommandRecorder,
-  options?: { kernelPath?: KernelPathSchema | null }
-): Promise<Tensor>;