@simulatte/doppler 0.1.5 → 0.1.7

package/src/inference/pipelines/structured/json-head-pipeline.js

@@ -84,20 +84,35 @@ function parseStructuredJSONObject(rawText) {
 function resolveStructuredRuntime(manifest, runtimeConfig) {
   const modelCfg = isObj(manifest?.inference?.structuredJsonHead)
     ? manifest.inference.structuredJsonHead
-    : (isObj(manifest?.inference?.dream) ? manifest.inference.dream : {});
+    : null;
+  if (!modelCfg) {
+    throw new Error('StructuredJsonHeadPipeline: manifest.inference.structuredJsonHead is required.');
+  }
   const runtimeCfg = isObj(runtimeConfig?.inference?.structuredJsonHead)
     ? runtimeConfig.inference.structuredJsonHead
-    : (isObj(runtimeConfig?.inference?.dream) ? runtimeConfig.inference.dream : {});
+    : {};
+  const resolvedMaxTokens = Number.isFinite(runtimeCfg.maxTokens)
+    ? Math.max(1, Math.floor(runtimeCfg.maxTokens))
+    : (Number.isFinite(modelCfg.maxTokens) ? Math.max(1, Math.floor(modelCfg.maxTokens)) : null);
+  const resolvedTemperature = Number.isFinite(runtimeCfg.temperature)
+    ? Number(runtimeCfg.temperature)
+    : (Number.isFinite(modelCfg.temperature) ? Number(modelCfg.temperature) : null);
+  const resolvedMaxOutputChars = Number.isFinite(runtimeCfg.maxOutputChars)
+    ? Math.max(4096, Math.floor(runtimeCfg.maxOutputChars))
+    : (Number.isFinite(modelCfg.maxOutputChars) ? Math.max(4096, Math.floor(modelCfg.maxOutputChars)) : null);
+  if (!Number.isFinite(resolvedMaxTokens)) {
+    throw new Error('StructuredJsonHeadPipeline: structuredJsonHead.maxTokens is required.');
+  }
+  if (!Number.isFinite(resolvedTemperature)) {
+    throw new Error('StructuredJsonHeadPipeline: structuredJsonHead.temperature is required.');
+  }
+  if (!Number.isFinite(resolvedMaxOutputChars)) {
+    throw new Error('StructuredJsonHeadPipeline: structuredJsonHead.maxOutputChars is required.');
+  }
   return {
-    maxTokens: Number.isFinite(runtimeCfg.maxTokens)
-      ? Math.max(1, Math.floor(runtimeCfg.maxTokens))
-      : (Number.isFinite(modelCfg.maxTokens) ? Math.max(1, Math.floor(modelCfg.maxTokens)) : 768),
-    temperature: Number.isFinite(runtimeCfg.temperature)
-      ? Number(runtimeCfg.temperature)
-      : (Number.isFinite(modelCfg.temperature) ? Number(modelCfg.temperature) : 0),
-    maxOutputChars: Number.isFinite(runtimeCfg.maxOutputChars)
-      ? Math.max(4096, Math.floor(runtimeCfg.maxOutputChars))
-      : (Number.isFinite(modelCfg.maxOutputChars) ? Math.max(4096, Math.floor(modelCfg.maxOutputChars)) : 262144),
+    maxTokens: resolvedMaxTokens,
+    temperature: resolvedTemperature,
+    maxOutputChars: resolvedMaxOutputChars,
   };
 }
 

package/src/inference/pipelines/text/attention/projections.js

@@ -1,4 +1,4 @@
-import { acquireBuffer } from '../../../../memory/buffer-pool.js';
+import { releaseBuffer } from '../../../../memory/buffer-pool.js';
 import { isWeightBuffer, getLayout, getWeightDtype } from '../../../../gpu/weight-buffer.js';
 import {
   runMatmul,
@@ -36,7 +36,7 @@ function getRmsNormRunner(recorder) {
 }
 
 function releaseOwnedWeightBuffer(layerWeight, resolvedWeightBuffer, releaseTemporary) {
-  if (layerWeight instanceof GPUBuffer || isWeightBuffer(layerWeight)) {
+  if ((typeof GPUBuffer !== 'undefined' && layerWeight instanceof GPUBuffer) || isWeightBuffer(layerWeight)) {
     return;
   }
   if (!resolvedWeightBuffer) {
@@ -66,10 +66,16 @@ async function projectSingleQkvTensor({
 }) {
   const runMatmulForMode = getMatmulRunner(recorder);
   const layerWeight = layerWeights?.[weightKey];
-  let projected;
+  if (!layerWeight) {
+    throw new Error(`Attention projection requires ${weightKey}.`);
+  }
+  if (!getWeightBuffer) {
+    throw new Error(`Attention projection requires getWeightBuffer for ${role}.`);
+  }
 
-  if (layerWeight && getWeightBuffer) {
-    const projBuffer = getWeightBuffer(layerWeight, role);
+  let projected;
+  const projBuffer = getWeightBuffer(layerWeight, role);
+  try {
     projected = await runMatmulForMode(normed, projBuffer, numTokens, outputSize, hiddenSize, {
       transposeB: 'auto',
       role,
@@ -77,26 +83,31 @@ async function projectSingleQkvTensor({
       kernelPath,
       outputDtype: matmulOutputDtype,
     });
+  } finally {
     releaseOwnedWeightBuffer(layerWeight, projBuffer, releaseTemporary);
-  } else {
-    const fallback = acquireBuffer(numTokens * outputSize * 4, undefined, outputLabel);
-    projected = createTensor(fallback, normed.dtype, [numTokens, outputSize], outputLabel);
   }
 
   const loraModule = getLoRAModule(lora, layerIdx, loraKey);
   if (loraModule && getWeightBuffer) {
-    const combined = await applyLoRA(
-      normed,
-      projected,
-      loraModule,
-      { M: numTokens, N: outputSize, K: hiddenSize },
-      getWeightBuffer,
-      recorder ?? undefined,
-      { kernelPath }
-    );
-    if (combined.buffer !== projected.buffer) {
-      releaseTemporary(projected.buffer);
-      projected = combined;
+    try {
+      const combined = await applyLoRA(
+        normed,
+        projected,
+        loraModule,
+        { M: numTokens, N: outputSize, K: hiddenSize },
+        getWeightBuffer,
+        recorder ?? undefined,
+        { kernelPath }
+      );
+      if (combined.buffer !== projected.buffer) {
+        releaseTemporary(projected.buffer);
+        projected = combined;
+      }
+    } catch (error) {
+      if (projected?.buffer) {
+        releaseTemporary(projected.buffer);
+      }
+      throw error;
     }
   }
 
@@ -212,24 +223,42 @@ async function projectQueryWithOptionalGate({
       bOffset: gateOffset,
       outputDtype: matmulOutputDtype,
     });
+  } catch (error) {
+    if (qTensor) {
+      releaseTemporary(qTensor.buffer);
+    }
+    if (qGateTensor) {
+      releaseTemporary(qGateTensor.buffer);
+    }
+    throw error;
   } finally {
     releaseOwnedWeightBuffer(qWeight, qWeightBuffer, releaseTemporary);
   }
 
   const loraModule = getLoRAModule(lora, layerIdx, 'q_proj');
   if (loraModule && getWeightBuffer) {
-    const combined = await applyLoRA(
-      normed,
-      qTensor,
-      loraModule,
-      { M: numTokens, N: qSize, K: hiddenSize },
-      getWeightBuffer,
-      recorder ?? undefined,
-      { kernelPath }
-    );
-    if (combined.buffer !== qTensor.buffer) {
-      releaseTemporary(qTensor.buffer);
-      qTensor = combined;
+    try {
+      const combined = await applyLoRA(
+        normed,
+        qTensor,
+        loraModule,
+        { M: numTokens, N: qSize, K: hiddenSize },
+        getWeightBuffer,
+        recorder ?? undefined,
+        { kernelPath }
+      );
+      if (combined.buffer !== qTensor.buffer) {
+        releaseTemporary(qTensor.buffer);
+        qTensor = combined;
+      }
+    } catch (error) {
+      if (qTensor?.buffer) {
+        releaseTemporary(qTensor.buffer);
+      }
+      if (qGateTensor?.buffer) {
+        releaseTemporary(qGateTensor.buffer);
+      }
+      throw error;
     }
   }
 
@@ -289,82 +318,103 @@ export async function projectAttentionQKV({
   if (useFusedQKV && layerWeights.qkvProj && layerWeights.qkvSizes) {
     const [qSizeFused, kSizeFused, vSizeFused] = layerWeights.qkvSizes;
     const qkvSizeTotal = qSizeFused + kSizeFused + vSizeFused;
-    const qkvTensor = await runMatmulForMode(normed, layerWeights.qkvProj, numTokens, qkvSizeTotal, hiddenSize, {
-      transposeB: 'auto',
-      role: 'qkv_proj',
+    let qkvTensor = null;
+    try {
+      qkvTensor = await runMatmulForMode(normed, layerWeights.qkvProj, numTokens, qkvSizeTotal, hiddenSize, {
+        transposeB: 'auto',
+        role: 'qkv_proj',
+        layerIdx,
+        kernelPath,
+        outputDtype: matmulOutputDtype,
+      });
+      const split = await runSplitForMode(qkvTensor, {
+        numTokens,
+        qSize: qSizeFused,
+        kSize: kSizeFused,
+        vSize: vSizeFused,
+      });
+      releaseTemporary(qkvTensor.buffer);
+      if (onFusedQKV) {
+        onFusedQKV({ qSize: qSizeFused, kSize: kSizeFused, vSize: vSizeFused, totalSize: qkvSizeTotal });
+      }
+      return { qTensor: split.Q, qGateTensor: null, kTensor: split.K, vTensor: split.V, usedFusedQKV: true };
+    } catch (error) {
+      if (qkvTensor) {
+        releaseTemporary(qkvTensor.buffer);
+      }
+      throw error;
+    }
+  }
+
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  try {
+    ({ qTensor, qGateTensor } = await projectQueryWithOptionalGate({
+      recorder,
+      normed,
+      layerWeights,
+      numTokens,
+      numHeads,
+      headDim,
+      hiddenSize,
       layerIdx,
       kernelPath,
-      outputDtype: matmulOutputDtype,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
+      attentionOutputGate,
+    }));
+
+    kTensor = await projectSingleQkvTensor({
+      recorder,
+      normed,
+      layerWeights,
+      weightKey: 'kProj',
+      role: 'k_proj',
+      outputSize: numKVHeads * headDim,
+      outputLabel: 'K',
+      loraKey: 'k_proj',
+      numTokens,
+      hiddenSize,
+      layerIdx,
+      kernelPath,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
     });
-    const split = await runSplitForMode(qkvTensor, {
+
+    vTensor = await projectSingleQkvTensor({
+      recorder,
+      normed,
+      layerWeights,
+      weightKey: 'vProj',
+      role: 'v_proj',
+      outputSize: numKVHeads * headDim,
+      outputLabel: 'V',
+      loraKey: 'v_proj',
       numTokens,
-      qSize: qSizeFused,
-      kSize: kSizeFused,
-      vSize: vSizeFused,
+      hiddenSize,
+      layerIdx,
+      kernelPath,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
     });
-    releaseTemporary(qkvTensor.buffer);
-    if (onFusedQKV) {
-      onFusedQKV({ qSize: qSizeFused, kSize: kSizeFused, vSize: vSizeFused, totalSize: qkvSizeTotal });
+
+    return { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV: false };
+  } catch (error) {
+    for (const tensor of [qTensor, qGateTensor, kTensor, vTensor]) {
+      if (tensor?.buffer) {
+        releaseTemporary(tensor.buffer);
+      }
     }
-    return { qTensor: split.Q, qGateTensor: null, kTensor: split.K, vTensor: split.V, usedFusedQKV: true };
+    throw error;
   }
-
-  const { qTensor, qGateTensor } = await projectQueryWithOptionalGate({
-    recorder,
-    normed,
-    layerWeights,
-    numTokens,
-    numHeads,
-    headDim,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-    attentionOutputGate,
-  });
-
-  const kTensor = await projectSingleQkvTensor({
-    recorder,
-    normed,
-    layerWeights,
-    weightKey: 'kProj',
-    role: 'k_proj',
-    outputSize: numKVHeads * headDim,
-    outputLabel: 'K',
-    loraKey: 'k_proj',
-    numTokens,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-  });
-
-  const vTensor = await projectSingleQkvTensor({
-    recorder,
-    normed,
-    layerWeights,
-    weightKey: 'vProj',
-    role: 'v_proj',
-    outputSize: numKVHeads * headDim,
-    outputLabel: 'V',
-    loraKey: 'v_proj',
-    numTokens,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-  });
-
-  return { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV: false };
 }
 
 export async function applyAttentionQKNorm({

package/src/inference/pipelines/text/attention/record.js

@@ -90,9 +90,20 @@ export async function recordLayerAttentionGPU(
   const allowF16Attention = wantsF16Output && kvCacheDtype === 'f16';
   let attentionInput = input;
   let attentionInputTemp = false;
+  let normed = attentionInput;
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  let attnOutput = null;
+  let attnForProjection = null;
+  let output = null;
+  let finalOutput = null;
+  let oProjInputTemp = null;
   if (wantsF16Output && !allowF16Attention) {
     attentionInput = await recordCastF16ToF32(recorder, input);
     attentionInputTemp = true;
+    normed = attentionInput;
   }
 
   if (!layerWeights) {
@@ -108,7 +119,7 @@ export async function recordLayerAttentionGPU(
 
   // 1. Input norm
 
-  let normed = attentionInput;
+  try {
   if (!skipInputNorm && layerWeights.inputNorm && getNormWeightBuffer) {
     const normWeightBuf = getNormWeightBuffer(layerWeights.inputNorm, 'input_norm');
     normed = await recordRMSNorm(recorder, attentionInput, normWeightBuf, rmsNormEps, {
@@ -132,7 +143,8 @@ export async function recordLayerAttentionGPU(
 
   // 2. Q/K/V projections
   const matmulOutputDtype = resolveAttentionProjectionOutputDtype(desiredOutputDtype);
-  let { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
+  let usedFusedQKV = false;
+  ({ qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
     recorder,
     normed,
     layerWeights,
@@ -153,7 +165,7 @@ export async function recordLayerAttentionGPU(
         trace.attn(layerIdx, `Using fused QKV path: ${qSizeFused}+${kSizeFused}+${vSizeFused}=${totalSize}`);
       }
       : null,
-  });
+  }));
 
   // Optional per-head Q/K normalization.
   // Some models use RMSNorm with (1+weight) offset formula, controlled by rmsNormWeightOffset.
@@ -182,10 +194,18 @@ export async function recordLayerAttentionGPU(
   // 3. RoPE (modifies tensor in-place)
   if (!disableRoPE && state.ropeFreqsCos && state.ropeFreqsSin) {
     await recordRoPE(recorder, qTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads, headDim, startPos: currentSeqLen,
+      numHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
     await recordRoPE(recorder, kTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads: numKVHeads, headDim, startPos: currentSeqLen,
+      numHeads: numKVHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
   }
 
@@ -494,14 +514,15 @@ export async function recordLayerAttentionGPU(
     throw new Error(`Unsupported attention kernel variant "${attentionKernelVariant}" at layer ${layerIdx}`);
   }
 
-  const attnOutput = await runAttentionKernel();
+  attnOutput = await runAttentionKernel();
 
-  let attnForProjection = attnOutput;
+  attnForProjection = attnOutput;
   if (qGateTensor) {
     attnForProjection = await recordSiLU(recorder, attnOutput, {
       size: numTokens * numHeads * headDim,
       gate: qGateTensor,
       gateActivation: 'sigmoid',
+      inputActivation: 'identity',
       swigluLimit: null,
     });
     recorder.trackTemporaryBuffer(attnOutput.buffer);
@@ -509,10 +530,10 @@ export async function recordLayerAttentionGPU(
 
   // 6. Output projection (with optional fused residual for decode)
 
-  let output;
+  output = null;
   let residualFused = false;
   let oProjInput = attnForProjection;
-  let oProjInputTemp = null;
+  oProjInputTemp = null;
   if (layerWeights.oProj && getWeightBuffer) {
     const oProjBuf = getWeightBuffer(layerWeights.oProj, 'o_proj');
     const loraO = getLoRAModule(lora, layerIdx, 'o_proj');
@@ -580,7 +601,7 @@ export async function recordLayerAttentionGPU(
     }
   }
 
-  let finalOutput = output;
+  finalOutput = output;
 
   const buffersToTrack = [];
   if (output.buffer !== attnForProjection.buffer) {
@@ -610,4 +631,46 @@ export async function recordLayerAttentionGPU(
   }
 
   return { output: finalOutput, residualFused };
+  } catch (error) {
+    const tracked = new Set();
+    const trackOnce = (buffer) => {
+      if (!buffer || tracked.has(buffer)) return;
+      tracked.add(buffer);
+      recorder.trackTemporaryBuffer(buffer);
+    };
+    if (finalOutput?.buffer && finalOutput.buffer !== output?.buffer) {
+      trackOnce(finalOutput.buffer);
+    }
+    if (output?.buffer && output.buffer !== attnForProjection?.buffer) {
+      trackOnce(output.buffer);
+    }
+    if (oProjInputTemp?.buffer) {
+      trackOnce(oProjInputTemp.buffer);
+    }
+    if (attnForProjection?.buffer && attnForProjection.buffer !== attnOutput?.buffer) {
+      trackOnce(attnForProjection.buffer);
+    }
+    if (attnOutput?.buffer) {
+      trackOnce(attnOutput.buffer);
+    }
+    if (qGateTensor?.buffer) {
+      trackOnce(qGateTensor.buffer);
+    }
+    if (qTensor?.buffer) {
+      trackOnce(qTensor.buffer);
+    }
+    if (kTensor?.buffer) {
+      trackOnce(kTensor.buffer);
+    }
+    if (vTensor?.buffer) {
+      trackOnce(vTensor.buffer);
+    }
+    if (normed?.buffer && normed.buffer !== attentionInput?.buffer) {
+      trackOnce(normed.buffer);
+    }
+    if (attentionInputTemp && attentionInput?.buffer) {
+      trackOnce(attentionInput.buffer);
+    }
+    throw error;
+  }
 }

package/src/inference/pipelines/text/attention/run.js

@@ -97,9 +97,20 @@ export async function runLayerAttentionGPU(
   const allowF16Attention = wantsF16Output && kvCacheDtype === 'f16';
   let attentionInput = input;
   let attentionInputTemp = false;
+  let normed = attentionInput;
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  let attnOutput = null;
+  let attnForProjection = null;
+  let output = null;
+  let finalOutput = null;
+  let oProjInputTemp = null;
   if (wantsF16Output && !allowF16Attention) {
     attentionInput = await castF16ToF32(input);
     attentionInputTemp = true;
+    normed = attentionInput;
   }
 
   // Debug: attention input for configured layers
@@ -123,7 +134,7 @@ export async function runLayerAttentionGPU(
 
   // 1. Input norm
   
-  let normed = attentionInput;
+  try {
   if (!skipInputNorm && layerWeights.inputNorm && getNormWeightBuffer) {
     const normWeightBuf = getNormWeightBuffer(layerWeights.inputNorm, 'input_norm');
 
@@ -183,7 +194,8 @@ export async function runLayerAttentionGPU(
 
   // 2. Q/K/V projections
   const matmulOutputDtype = resolveAttentionProjectionOutputDtype(desiredOutputDtype);
-  let { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
+  let usedFusedQKV = false;
+  ({ qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
     recorder: null,
     normed,
     layerWeights,
@@ -204,7 +216,7 @@ export async function runLayerAttentionGPU(
         trace.attn(layerIdx, `Using fused QKV path: ${qSizeFused}+${kSizeFused}+${vSizeFused}=${totalSize}`);
       }
       : null,
-  });
+  }));
 
   // Trace Q/K/V projections
   if (kernelTrace.enabled) {
@@ -299,10 +311,18 @@ export async function runLayerAttentionGPU(
 
   if (!disableRoPE && state.ropeFreqsCos && state.ropeFreqsSin) {
     await runRoPE(qTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads, headDim, startPos: currentSeqLen,
+      numHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
     await runRoPE(kTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads: numKVHeads, headDim, startPos: currentSeqLen,
+      numHeads: numKVHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
 
     // Trace RoPE outputs
@@ -661,7 +681,7 @@ export async function runLayerAttentionGPU(
     throw new Error(`Unsupported attention kernel variant "${attentionKernelVariant}" at layer ${layerIdx}`);
   }
 
-  const attnOutput = await runAttentionKernel();
+  attnOutput = await runAttentionKernel();
 
   // Trace attention output
   if (kernelTrace.enabled) {
@@ -684,12 +704,13 @@ export async function runLayerAttentionGPU(
     await debugCheckBuffer(attnOutput.buffer, `L${layerIdx} attention output (before o_proj, GPU)`, numTokens, numHeads * headDim);
   }
 
-  let attnForProjection = attnOutput;
+  attnForProjection = attnOutput;
   if (qGateTensor) {
     attnForProjection = await runSiLU(attnOutput, {
       size: numTokens * numHeads * headDim,
       gate: qGateTensor,
       gateActivation: 'sigmoid',
+      inputActivation: 'identity',
       swigluLimit: null,
     });
     releaseBuffer(attnOutput.buffer);
@@ -697,10 +718,10 @@ export async function runLayerAttentionGPU(
 
   // 6. Output projection (with optional fused residual for decode)
   
-  let output;
+  output = null;
   let residualFused = false;
   let oProjInput = attnForProjection;
-  let oProjInputTemp = null;
+  oProjInputTemp = null;
   if (layerWeights.oProj && getWeightBuffer) {
     const oProjBuf = getWeightBuffer(layerWeights.oProj, 'o_proj');
     const loraO = getLoRAModule(lora, layerIdx, 'o_proj');
@@ -798,7 +819,7 @@ export async function runLayerAttentionGPU(
     await debugCheckBuffer(output.buffer, `L${layerIdx} attention output (after o_proj, GPU)`, numTokens, hiddenSize);
   }
 
-  let finalOutput = output;
+  finalOutput = output;
   
   const buffersToRelease = [];
   if (output.buffer !== attnForProjection.buffer) {
@@ -823,4 +844,46 @@ export async function runLayerAttentionGPU(
   }
 
   return { output: finalOutput, residualFused };
+  } catch (error) {
+    const released = new Set();
+    const releaseOnce = (buffer) => {
+      if (!buffer || released.has(buffer)) return;
+      released.add(buffer);
+      releaseBuffer(buffer);
+    };
+    if (finalOutput?.buffer && finalOutput.buffer !== output?.buffer) {
+      releaseOnce(finalOutput.buffer);
+    }
+    if (output?.buffer && output.buffer !== attnForProjection?.buffer) {
+      releaseOnce(output.buffer);
+    }
+    if (oProjInputTemp?.buffer) {
+      releaseOnce(oProjInputTemp.buffer);
+    }
+    if (attnForProjection?.buffer && attnForProjection.buffer !== attnOutput?.buffer) {
+      releaseOnce(attnForProjection.buffer);
+    }
+    if (attnOutput?.buffer) {
+      releaseOnce(attnOutput.buffer);
+    }
+    if (qGateTensor?.buffer) {
+      releaseOnce(qGateTensor.buffer);
+    }
+    if (qTensor?.buffer) {
+      releaseOnce(qTensor.buffer);
+    }
+    if (kTensor?.buffer) {
+      releaseOnce(kTensor.buffer);
+    }
+    if (vTensor?.buffer) {
+      releaseOnce(vTensor.buffer);
+    }
+    if (normed?.buffer && normed.buffer !== attentionInput?.buffer) {
+      releaseOnce(normed.buffer);
+    }
+    if (attentionInputTemp && attentionInput?.buffer) {
+      releaseOnce(attentionInput.buffer);
+    }
+    throw error;
+  }
 }