@simulatte/doppler 0.1.6 → 0.1.8

package/src/inference/pipelines/text/linear-attention.js

@@ -4,6 +4,9 @@ import { readBuffer, releaseBuffer, uploadData, acquireBuffer } from '../../../m
 import { log } from '../../../debug/index.js';
 import { decodeReadback } from './debug-utils/index.js';
 import { runLinearAttentionCoreGPU } from '../../../gpu/kernels/linear-attention-core.js';
+import { runProbes } from './probes.js';
+import { QK_K, Q4K_BLOCK_BYTES } from '../../../config/schema/index.js';
+import { dequantizeQ4KM } from '../../../converter/quantizer.js';
 
 const LINEAR_RUNTIME_SCHEMA_VERSION = 1;
 const QK_L2NORM_EPS = 1e-6;
@@ -33,6 +36,15 @@ function bytesFromDtype(dtype) {
   return 4;
 }
 
+export function applyLinearNormWeightOffset(values, rmsNormWeightOffset) {
+  if (!(values instanceof Float32Array)) {
+    throw new Error('applyLinearNormWeightOffset requires Float32Array input.');
+  }
+  // Qwen linear-attention output norm uses direct weights even when surrounding
+  // transformer RMSNorm sites use the Gemma-style (1 + weight) formula.
+  return values;
+}
+
 function cloneLayerRuntimeState(layerState) {
   return {
     layerIdx: layerState.layerIdx,
@@ -173,9 +185,22 @@ function inferLinearNormModeFromWeight(weight, projectionLayout) {
   if (weight instanceof ArrayBuffer) {
     return classify(Math.trunc(weight.byteLength / Float32Array.BYTES_PER_ELEMENT));
   }
+  const explicitDtype = typeof weight?.dtype === 'string' ? weight.dtype.toLowerCase() : null;
+  const trackedDtype = isGpuBuffer(weight) ? String(getBufferDtype(weight) ?? '').toLowerCase() : '';
+  const bytesPerElement = bytesFromDtype(explicitDtype || trackedDtype || null);
+  const sizedElements = Number.isFinite(weight?.size)
+    ? Math.trunc(Number(weight.size) / bytesPerElement)
+    : null;
+  if (sizedElements && Number(weight.size) % bytesPerElement === 0) {
+    return classify(sizedElements);
+  }
   return null;
 }
 
+export function inferLinearNormMode(weight, projectionLayout) {
+  return inferLinearNormModeFromWeight(weight, projectionLayout);
+}
+
 function resolveLinearNormMode(configNormMode, normWeight, projectionLayout, layerIdx) {
   const configuredMode = normalizeLinearNormMode(configNormMode);
   const inferredMode = inferLinearNormModeFromWeight(normWeight, projectionLayout);
@@ -185,7 +210,15 @@ function resolveLinearNormMode(configNormMode, normWeight, projectionLayout, lay
       `but norm.weight shape implies "${inferredMode}".`
     );
   }
-  return configuredMode ?? inferredMode ?? 'shared';
+  if (configuredMode) {
+    return configuredMode;
+  }
+  if (inferredMode) {
+    return inferredMode;
+  }
+  throw new Error(
+    `linear_attention layer ${layerIdx} requires explicit linearNormMode or a norm.weight shape that resolves it.`
+  );
 }
 
 async function readWeightAsF32(weight, expectedElements, label) {
@@ -261,9 +294,27 @@ async function readWeightAsF32(weight, expectedElements, label) {
   if (!elementCount && isWeightBuffer(weight) && Array.isArray(weight.shape) && weight.shape.length > 0) {
     elementCount = weight.shape.reduce((total, dim) => total * Math.max(1, Math.trunc(Number(dim) || 0)), 1);
   }
+  const isQ4K = sourceDtype === 'q4k' || sourceDtype === 'q4_k_m' || sourceDtype === 'q4_k';
   if (!elementCount) {
-    const inferredBytes = sourceDtype === 'f16' || sourceDtype === 'bf16' ? 2 : 4;
-    elementCount = Math.trunc(sourceBuffer.size / inferredBytes);
+    if (isQ4K) {
+      elementCount = Math.trunc(sourceBuffer.size / Q4K_BLOCK_BYTES) * QK_K;
+    } else {
+      const inferredBytes = sourceDtype === 'f16' || sourceDtype === 'bf16' ? 2 : 4;
+      elementCount = Math.trunc(sourceBuffer.size / inferredBytes);
+    }
+  }
+
+  if (isQ4K) {
+    const numBlocks = Math.ceil(elementCount / QK_K);
+    const q4kBytes = numBlocks * Q4K_BLOCK_BYTES;
+    const raw = await readBuffer(sourceBuffer, q4kBytes);
+    const decoded = dequantizeQ4KM(new Uint8Array(raw), numBlocks, [elementCount]);
+    if (expectedElements != null && decoded.length !== expectedElements) {
+      throw new Error(
+        `Weight "${label}" Q4K decoded length ${decoded.length}, expected ${expectedElements}.`
+      );
+    }
+    return decoded;
   }
 
   if (!sourceDtype) {
@@ -395,10 +446,17 @@ async function createLayerRuntimeState(
 
   let convKernelSize = toPositiveInt(config.linearConvKernelDim) ?? null;
   if (isWeightBuffer(convKernel) && Array.isArray(convKernel.shape) && convKernel.shape.length >= 3) {
-    convKernelSize = toPositiveInt(convKernel.shape[2]) ?? convKernelSize;
+    const shapeKernelSize = toPositiveInt(convKernel.shape[2]) ?? null;
+    if (convKernelSize != null && shapeKernelSize != null && convKernelSize !== shapeKernelSize) {
+      throw new Error(
+        `linear_attention layer ${layerIdx} declares linearConvKernelDim=${convKernelSize}, ` +
+        `but conv1d weight shape implies ${shapeKernelSize}.`
+      );
+    }
+    convKernelSize = shapeKernelSize ?? convKernelSize;
   }
   if (!convKernelSize) {
-    convKernelSize = 4;
+    throw new Error(`linear_attention layer ${layerIdx} requires linearConvKernelDim.`);
   }
 
   const convWeight = await readWeightAsF32(
@@ -425,6 +483,7 @@ async function createLayerRuntimeState(
     expectedNormElements,
     `L${layerIdx}.linear_attn.norm.weight`
   );
+  const runtimeNorm = applyLinearNormWeightOffset(norm, config.rmsNormWeightOffset === true);
 
   const aNegExp = new Float32Array(aLog.length);
   for (let i = 0; i < aLog.length; i++) {
@@ -435,6 +494,11 @@ async function createLayerRuntimeState(
   const recurrentState = new Float32Array(
     projectionLayout.numVHeads * projectionLayout.headKDim * projectionLayout.headVDim
   );
+  const rmsNormEps = Number(config.rmsNormEps);
+  if (!Number.isFinite(rmsNormEps) || rmsNormEps <= 0) {
+    throw new Error(`linear_attention layer ${layerIdx} requires a positive rmsNormEps.`);
+  }
+
   const layerState = {
     layerIdx,
     seqLen: currentSeqLen,
@@ -452,11 +516,11 @@ async function createLayerRuntimeState(
     vSize: projectionLayout.vSize,
     qRep: projectionLayout.qRep,
     normMode,
-    rmsNormEps: Number(config.rmsNormEps) || 1e-6,
+    rmsNormEps,
     convWeight,
     dtBias,
     aNegExp,
-    normWeight: norm,
+    normWeight: runtimeNorm,
     convState,
     recurrentState,
     convWeightGPU: null,
@@ -681,13 +745,13 @@ export async function runLinearAttentionLayer(inputTensor, layerWeights, options
     const normWeightBuffer = getNormWeightBuffer(layerWeights.inputNorm, `L${layerIdx}.linear_input_norm`);
     try {
       if (recorder) {
-        normedTensor = await recordRMSNorm(recorder, inputTensor, normWeightBuffer, Number(config.rmsNormEps) || 1e-6, {
+        normedTensor = await recordRMSNorm(recorder, inputTensor, normWeightBuffer, layerState.rmsNormEps, {
           batchSize: numTokens,
           hiddenSize,
           rmsNormWeightOffset: config.rmsNormWeightOffset,
         });
       } else {
-        normedTensor = await runRMSNorm(inputTensor, normWeightBuffer, Number(config.rmsNormEps) || 1e-6, {
+        normedTensor = await runRMSNorm(inputTensor, normWeightBuffer, layerState.rmsNormEps, {
           batchSize: numTokens,
           hiddenSize,
           rmsNormWeightOffset: config.rmsNormWeightOffset,
@@ -755,6 +819,38 @@ export async function runLinearAttentionLayer(inputTensor, layerWeights, options
   });
 
   try {
+    await runProbes('linear_qkv_proj', qkvTensor.buffer, {
+      layerIdx,
+      numTokens,
+      hiddenSize: projectionLayout.convDim,
+      probes: options.debugProbes,
+      recorder,
+      dtype: qkvTensor.dtype,
+    });
+    await runProbes('linear_z_proj', zTensor.buffer, {
+      layerIdx,
+      numTokens,
+      hiddenSize: projectionLayout.valueDim,
+      probes: options.debugProbes,
+      recorder,
+      dtype: zTensor.dtype,
+    });
+    await runProbes('linear_a_proj', aTensor.buffer, {
+      layerIdx,
+      numTokens,
+      hiddenSize: projectionLayout.numVHeads,
+      probes: options.debugProbes,
+      recorder,
+      dtype: aTensor.dtype,
+    });
+    await runProbes('linear_b_proj', bTensor.buffer, {
+      layerIdx,
+      numTokens,
+      hiddenSize: projectionLayout.numVHeads,
+      probes: options.debugProbes,
+      recorder,
+      dtype: bTensor.dtype,
+    });
     const coreTensor = await runLinearAttentionCoreGPU(
       qkvTensor,
       zTensor,
@@ -768,6 +864,14 @@ export async function runLinearAttentionLayer(inputTensor, layerWeights, options
         recorder,
       }
     );
+    await runProbes('linear_core_out', coreTensor.buffer, {
+      layerIdx,
+      numTokens,
+      hiddenSize: projectionLayout.valueDim,
+      probes: options.debugProbes,
+      recorder,
+      dtype: coreTensor.dtype,
+    });
     layerState.seqLen = currentSeqLen + numTokens;
     const outProjWeight = getWeightBuffer(layerWeights.oProj, `L${layerIdx}.linear_out_proj`);
     try {

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

@@ -1,7 +1,7 @@
 
 
 import { getDevice, getKernelCapabilities } from '../../../../gpu/device.js';
-import { acquireBuffer, releaseBuffer, readBuffer } from '../../../../memory/buffer-pool.js';
+import { acquireBuffer, releaseBuffer } from '../../../../memory/buffer-pool.js';
 import { runMatmul, runRMSNorm } from '../../../../gpu/kernel-selector.js';
 import { recordMatmul } from '../../../../gpu/kernels/matmul.js';
 import { recordRMSNorm } from '../../../../gpu/kernels/rmsnorm.js';
@@ -13,6 +13,7 @@ import { getRuntimeConfig } from '../../../../config/runtime.js';
 import { selectRuleValue } from '../../../../rules/rule-registry.js';
 import { runProbes } from '../probes.js';
 import { f16BufferToF32 } from './cpu.js';
+import { readBufferWithCleanup } from './utils.js';
 
 function shouldForceStableF32Logits(config, inputDtype) {
   // Small Gemma-family checkpoints can overflow in pure F16 logits path after RMSNorm offset.
@@ -187,14 +188,18 @@ export async function computeChunkedLogitsGPU(
     }
 
     const logitsBytes = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: logitsTensor.dtype });
-    const chunkLogitsData = await readBuffer(logitsTensor.buffer, numTokens * rowCount * logitsBytes);
+    const chunkLogitsData = await readBufferWithCleanup(
+      logitsTensor.buffer,
+      numTokens * rowCount * logitsBytes,
+      () => {
+        releaseBuffer(logitsTensor.buffer);
+        releaseBuffer(weightBuffer.buffer);
+      }
+    );
     const chunkLogits = logitsTensor.dtype === 'f16'
       ? f16BufferToF32(chunkLogitsData)
       : new Float32Array(chunkLogitsData);
     writeChunkLogits(logits, chunkLogits, numTokens, vocabSize, rowOffset, rowCount);
-
-    releaseBuffer(logitsTensor.buffer);
-    releaseBuffer(weightBuffer.buffer);
   }
 
   return logits;
@@ -299,7 +304,7 @@ export async function computeLogitsGPU(
 
   const logitsTensor = await runMatmul(normedTensor, lmHeadBuffer, numTokens, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: forceStableF32Logits ? undefined : 'lm_head',
+    role: 'lm_head',
     kernelPath: config.kernelPath ?? null,
   });
 
@@ -386,7 +391,7 @@ export async function recordLogitsGPU(
   // Record matmul (no submit)
   const logitsTensor = await recordMatmul(recorder, normedTensor, lmHeadBuffer, numTokens, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: forceStableF32Logits ? undefined : 'lm_head',
+    role: 'lm_head',
     kernelPath: config.kernelPath ?? null,
   });
 

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

@@ -25,6 +25,10 @@ export { computeLogitsGPU, recordLogitsGPU, computeChunkedLogitsGPU, resolveCpuW
 // Re-export utilities
 export { extractLastPositionLogits, finalizeLogits } from './utils.js';
 
+export interface ComputeLogitsOptions {
+  lastPositionOnly?: boolean;
+}
+
 /**
  * Compute logits from hidden states.
  *
@@ -53,5 +57,6 @@ export function computeLogits(
   debugFlags?: LogitsDebugFlags,
   getNormWeightBuffer?: (weight: GPUBuffer | Float32Array | ArrayBuffer, label: string) => GPUBuffer,
   debugCheckBuffer?: (buffer: GPUBuffer, label: string, numTokens: number, expectedDim?: number) => Promise<void>,
-  debugProbes?: ProbeConfigSchema[] | null
+  debugProbes?: ProbeConfigSchema[] | null,
+  options?: ComputeLogitsOptions
 ): Promise<Float32Array>;

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

@@ -7,7 +7,7 @@ export { rmsNormCPU, matmulCPU, applySoftcapping, f16ToF32, f16BufferToF32 } fro
 export { computeLogitsGPU, recordLogitsGPU, computeChunkedLogitsGPU, resolveCpuWeightDims, resolveLmHeadChunkRows, extractLmHeadChunk, writeChunkLogits } from './gpu.js';
 
 // Re-export utilities
-export { extractLastPositionLogits, finalizeLogits } from './utils.js';
+export { extractLastPositionLogits, finalizeLogits, readBufferWithCleanup } from './utils.js';
 
 // Imports for computeLogits orchestrator
 import { getDevice } from '../../../../gpu/device.js';
@@ -20,7 +20,7 @@ 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 } from './utils.js';
+import { finalizeLogits, readBufferWithCleanup } from './utils.js';
 import { getRuntimeConfig } from '../../../../config/runtime.js';
 import { selectRuleValue } from '../../../../rules/rule-registry.js';
 
@@ -253,6 +253,7 @@ export async function computeLogits(
 
   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) {
@@ -270,7 +271,8 @@ export async function computeLogits(
   // HuggingFace models store lm_head as [vocabSize, hiddenSize], so transposeB=true
   const logitsTensor = await runMatmul(matmulInputTensor, lmHeadBuffer, matmulRows, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: (forceStableF32Logits || lastPositionOnly) ? undefined : 'lm_head',
+    role: 'lm_head',
+    phaseOverride: matmulPhaseOverride,
     kernelPath: config.kernelPath ?? null,
   });
   await runProbes('logits', logitsTensor.buffer, {
@@ -288,15 +290,14 @@ export async function computeLogits(
   // 4. Read back logits
   const logitsBytes = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: logitsTensor.dtype });
   const logitsReadSize = matmulRows * matmulVocabSize * logitsBytes;
-  const logitsData = await readBuffer(logitsTensor.buffer, logitsReadSize);
-
-  // Cleanup
-  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 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)

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

@@ -25,6 +25,13 @@ export function extractLastPositionLogits(
   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.
  *

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

@@ -1,5 +1,6 @@
 
 
+import { readBuffer } from '../../../../memory/buffer-pool.js';
 import { runProbes } from '../probes.js';
 import { applySoftcapping } from './cpu.js';
 
@@ -19,6 +20,14 @@ export function extractLastPositionLogits(
   return lastPosLogits;
 }
 
+export async function readBufferWithCleanup(buffer, byteLength, cleanup, reader = readBuffer) {
+  try {
+    return await reader(buffer, byteLength);
+  } finally {
+    cleanup?.();
+  }
+}
+
 
 export async function finalizeLogits(
   rawLogits,

package/src/inference/pipelines/text/lora-apply.js

@@ -17,42 +17,60 @@ export async function applyLoRA(input, baseOutput, lora, dims, getWeightBuffer,
 
   const aBuf = getWeightBuffer(lora.a, 'lora_a');
   const bBuf = getWeightBuffer(lora.b, 'lora_b');
-  const ownsA = !(lora.a instanceof GPUBuffer) && !isWeightBuffer(lora.a);
-  const ownsB = !(lora.b instanceof GPUBuffer) && !isWeightBuffer(lora.b);
-
-  const loraIntermediate = recorder
-    ? await recordMatmul(recorder, input, aBuf, M, rank, K, { transposeB: 'auto', role: 'lora_a', kernelPath })
-    : await runMatmul(input, aBuf, M, rank, K, { transposeB: 'auto', role: 'lora_a', kernelPath });
+  const ownsA = !(typeof GPUBuffer !== 'undefined' && lora.a instanceof GPUBuffer) && !isWeightBuffer(lora.a);
+  const ownsB = !(typeof GPUBuffer !== 'undefined' && lora.b instanceof GPUBuffer) && !isWeightBuffer(lora.b);
+  // Extract underlying GPUBuffer for WeightBuffers
+  const aBufGPU = isWeightBuffer(aBuf) ? aBuf.buffer : aBuf;
+  const bBufGPU = isWeightBuffer(bBuf) ? bBuf.buffer : bBuf;
+  let loraIntermediate = null;
+  let loraOutput = null;
+  let scaled = null;
+  try {
+    loraIntermediate = recorder
+      ? await recordMatmul(recorder, input, aBuf, M, rank, K, { transposeB: 'auto', role: 'lora_a', kernelPath })
+      : await runMatmul(input, aBuf, M, rank, K, { transposeB: 'auto', role: 'lora_a', kernelPath });
 
-  const loraOutput = recorder
-    ? await recordMatmul(recorder, loraIntermediate, bBuf, M, N, rank, { transposeB: 'auto', role: 'lora_b', kernelPath })
-    : await runMatmul(loraIntermediate, bBuf, M, N, rank, { transposeB: 'auto', role: 'lora_b', kernelPath });
+    loraOutput = recorder
+      ? await recordMatmul(recorder, loraIntermediate, bBuf, M, N, rank, { transposeB: 'auto', role: 'lora_b', kernelPath })
+      : await runMatmul(loraIntermediate, bBuf, M, N, rank, { transposeB: 'auto', role: 'lora_b', kernelPath });
 
-  const scaled = recorder
-    ? await recordScale(recorder, loraOutput, lora.scale, { outputBuffer: null })
-    : await runScale(loraOutput, lora.scale, { outputBuffer: null });
+    scaled = recorder
+      ? await recordScale(recorder, loraOutput, lora.scale, { outputBuffer: null })
+      : await runScale(loraOutput, lora.scale, { outputBuffer: null });
 
-  const combined = recorder
-    ? await recordResidualAdd(recorder, baseOutput, scaled, M * N)
-    : await runResidualAdd(baseOutput, scaled, M * N);
+    const combined = recorder
+      ? await recordResidualAdd(recorder, baseOutput, scaled, M * N)
+      : await runResidualAdd(baseOutput, scaled, M * N);
 
-  // Extract underlying GPUBuffer for WeightBuffers
-  const aBufGPU = isWeightBuffer(aBuf) ? aBuf.buffer : aBuf;
-  const bBufGPU = isWeightBuffer(bBuf) ? bBuf.buffer : bBuf;
+    if (recorder) {
+      recorder.trackTemporaryBuffer(loraIntermediate.buffer);
+      recorder.trackTemporaryBuffer(loraOutput.buffer);
+      recorder.trackTemporaryBuffer(scaled.buffer);
+      if (ownsA) recorder.trackTemporaryBuffer(aBufGPU);
+      if (ownsB) recorder.trackTemporaryBuffer(bBufGPU);
+    } else {
+      releaseBuffer(loraIntermediate.buffer);
+      releaseBuffer(loraOutput.buffer);
+      releaseBuffer(scaled.buffer);
+      if (ownsA) releaseBuffer(aBufGPU);
+      if (ownsB) releaseBuffer(bBufGPU);
+    }
 
-  if (recorder) {
-    recorder.trackTemporaryBuffer(loraIntermediate.buffer);
-    recorder.trackTemporaryBuffer(loraOutput.buffer);
-    recorder.trackTemporaryBuffer(scaled.buffer);
-    if (ownsA) recorder.trackTemporaryBuffer(aBufGPU);
-    if (ownsB) recorder.trackTemporaryBuffer(bBufGPU);
-  } else {
-    releaseBuffer(loraIntermediate.buffer);
-    releaseBuffer(loraOutput.buffer);
-    releaseBuffer(scaled.buffer);
-    if (ownsA) releaseBuffer(aBufGPU);
-    if (ownsB) releaseBuffer(bBufGPU);
+    return combined;
+  } catch (error) {
+    if (recorder) {
+      if (loraIntermediate) recorder.trackTemporaryBuffer(loraIntermediate.buffer);
+      if (loraOutput) recorder.trackTemporaryBuffer(loraOutput.buffer);
+      if (scaled) recorder.trackTemporaryBuffer(scaled.buffer);
+      if (ownsA) recorder.trackTemporaryBuffer(aBufGPU);
+      if (ownsB) recorder.trackTemporaryBuffer(bBufGPU);
+    } else {
+      if (loraIntermediate) releaseBuffer(loraIntermediate.buffer);
+      if (loraOutput) releaseBuffer(loraOutput.buffer);
+      if (scaled) releaseBuffer(scaled.buffer);
+      if (ownsA) releaseBuffer(aBufGPU);
+      if (ownsB) releaseBuffer(bBufGPU);
+    }
+    throw error;
   }
-
-  return combined;
 }