@simulatte/doppler 0.1.8 → 0.1.9

package/src/config/schema/storage.schema.js

@@ -16,7 +16,7 @@ export const DEFAULT_QUOTA_CONFIG = {
 
 export const DEFAULT_VRAM_ESTIMATION_CONFIG = {
   unifiedMemoryRatio: 0.5, // 50% of system RAM
-  fallbackVramBytes: 2 * GB,
+  fallbackVramBytes: 4 * GB,
   lowVramHeadroomBytes: 500 * MB,
 };
 

package/src/converter/conversion-plan.js

@@ -473,7 +473,7 @@ export function resolveConversionPlan(options) {
   // role dtypes should not change kernel-path selection when explicit compute precision is targeted.
   const embedDtypeRaw = normalizeWeightDtype(findTensorDtypeByRole(tensors, 'embedding'));
   const lmHeadDtypeRaw = normalizeWeightDtype(findTensorDtypeByRole(tensors, 'lm_head'));
-  const hasVision = hasAnyTensorPattern(tensors, ['vision_', 'vision_tower', 'vision_model', 'image_encoder']);
+  const hasVision = hasAnyTensorPattern(tensors, ['vision_', 'vision_tower', 'vision_model', 'image_encoder', 'visual.']);
   const hasAudio = hasAnyTensorPattern(tensors, ['audio_', 'audio_encoder', 'whisper', 'wav2vec']);
   const hasProjector = hasAnyTensorPattern(tensors, ['multi_modal_projector', 'mm_projector', 'projector']);
   const quantizationInfo = buildQuantizationInfo(

package/src/converter/core.js

@@ -114,6 +114,15 @@ export function resolveTensorTargetQuant(tensorName, fallbackQuant, quantization
     const headQuant = quantizationInfo.lmHead ?? quantizationInfo.embeddings ?? fallback;
     return normalizeStorageQuant(headQuant) ?? fallback;
   }
+  if (role === 'vision') {
+    return normalizeStorageQuant(quantizationInfo.vision ?? fallback) ?? fallback;
+  }
+  if (role === 'projector') {
+    return normalizeStorageQuant(quantizationInfo.projector ?? fallback) ?? fallback;
+  }
+  if (role === 'audio') {
+    return normalizeStorageQuant(quantizationInfo.audio ?? fallback) ?? fallback;
+  }
   return normalizeStorageQuant(quantizationInfo.weights ?? fallback) ?? fallback;
 }
 
@@ -819,11 +828,11 @@ export function extractArchitecture(config, ggufConfig) {
       vocabSize,
       maxSeqLen,
       ropeTheta,
-      linearNumKeyHeads: linearNumKeyHeads ?? undefined,
-      linearNumValueHeads: linearNumValueHeads ?? undefined,
-      linearKeyHeadDim: linearKeyHeadDim ?? undefined,
-      linearValueHeadDim: linearValueHeadDim ?? undefined,
-      linearConvKernelDim: linearConvKernelDim ?? undefined,
+      linearNumKeyHeads,
+      linearNumValueHeads,
+      linearKeyHeadDim,
+      linearValueHeadDim,
+      linearConvKernelDim,
       linearNormMode,
     };
   }
@@ -1056,7 +1065,7 @@ export function createManifest(
     modelId,
     modelType: resolvedModelType,
     quantization: resolvedQuantization,
-    quantizationInfo: options.quantizationInfo ?? undefined,
+    quantizationInfo: options.quantizationInfo,
     architecture: resolvedArchitecture,
     moeConfig,
     inference,
@@ -1065,8 +1074,8 @@ export function createManifest(
     totalSize: shards.reduce((sum, s) => sum + s.size, 0),
     hashAlgorithm,
     eos_token_id: eosTokenId,
-    config: isDiffusion ? rawConfig : undefined,
-    conversion: options.conversionInfo ?? undefined,
+    config: isDiffusion ? rawConfig : (rawConfig.vision_config ? { vision_config: rawConfig.vision_config } : undefined),
+    conversion: options.conversionInfo,
     metadata: {
       source,
       convertedAt: resolveConvertedAt(

package/src/converter/quantizer.d.ts

@@ -73,6 +73,11 @@ export declare function dequantizeQ4KM(
   shape: number[]
 ): Float32Array;
 
+export declare function dequantizeQ4KMRowWise(
+  quantized: Uint8Array,
+  shape: [number, number]
+): Float32Array;
+
 export declare function calculateQuantizationError(
   original: Float32Array,
   reconstructed: Float32Array

package/src/converter/quantizer.js

@@ -355,6 +355,21 @@ export function dequantizeQ4KM(quantized, numBlocks, shape) {
   return result;
 }
 
+export function dequantizeQ4KMRowWise(quantized, shape) {
+  const [rows, cols] = shape;
+  const blocksPerRow = Math.ceil(cols / QK_K);
+  const result = new Float32Array(rows * cols);
+
+  for (let row = 0; row < rows; row++) {
+    const rowOffset = row * blocksPerRow * QK4_K_BLOCK_SIZE;
+    const rowBytes = quantized.slice(rowOffset, rowOffset + (blocksPerRow * QK4_K_BLOCK_SIZE));
+    const rowDequantized = dequantizeQ4KM(rowBytes, blocksPerRow, [1, cols]);
+    result.set(rowDequantized, row * cols);
+  }
+
+  return result;
+}
+
 export function calculateQuantizationError(original, reconstructed) {
   if (original.length !== reconstructed.length) {
     throw new Error('Length mismatch');

package/src/distribution/shard-delivery.js

@@ -1317,6 +1317,25 @@ async function clearPersistedShardState(shardIndex) {
   await writer.abort?.();
 }
 
+async function recoverHttpRejectedResumeRange(
+  baseUrl,
+  shardInfo,
+  shardIndex,
+  options,
+  transferState,
+  writeToStore
+) {
+  await abortHttpTransferState(transferState);
+  if (writeToStore) {
+    await clearPersistedShardState(shardIndex);
+  }
+  return downloadShardFromHttp(baseUrl, shardInfo, shardIndex, {
+    ...options,
+    __disablePersistedResume: true,
+    __resumeRangeRecoveryAttempted: true,
+  });
+}
+
 async function downloadShardFromHttp(baseUrl, shardInfo, shardIndex, options = {}) {
   const {
     signal,
@@ -1529,6 +1548,21 @@ async function downloadShardFromHttp(baseUrl, shardInfo, shardIndex, options = {
         throw error;
       }
 
+      if (
+        error?.status === 416
+        && transferState.receivedBytes > 0
+        && options.__resumeRangeRecoveryAttempted !== true
+      ) {
+        return recoverHttpRejectedResumeRange(
+          baseUrl,
+          shardInfo,
+          shardIndex,
+          options,
+          transferState,
+          writeToStore
+        );
+      }
+
       if (Number.isInteger(error?.status) && error.status >= 400 && error.status < 500 && error.status !== 429) {
         await abortHttpTransferState(transferState);
         throw error;

package/src/formats/rdrr/classification.js

@@ -32,6 +32,12 @@ export function classifyTensor(name, modelType) {
     return 'head';
   }
 
+  // Multimodal groups
+  const role = classifyTensorRole(name);
+  if (role === 'vision') return 'vision';
+  if (role === 'projector') return 'projector';
+  if (role === 'audio') return 'audio';
+
   // Extract layer index
   const layerMatch = name.match(/layers?[._](\d+)/i);
   if (!layerMatch) {
@@ -96,6 +102,29 @@ export function classifyTensorRole(name) {
   if (lower.includes('lm_head')) return 'lm_head';
   if (lower.endsWith('output.weight') && !lower.includes('attn_')) return 'lm_head';
 
+  // Multimodal: vision encoder tensors
+  if (lower.startsWith('vision_tower.') || lower.startsWith('vision_model.')
+    || lower.startsWith('visual.') || lower.startsWith('model.visual.')
+    || lower.startsWith('vision.') || lower.startsWith('model.vision.')
+    || lower.startsWith('vision_encoder.') || lower.startsWith('image_encoder.')
+    || lower.startsWith('image_tower.') || lower.startsWith('image.')
+    || lower.startsWith('model.image.')) {
+    return 'vision';
+  }
+
+  // Multimodal: audio encoder tensors
+  if (lower.startsWith('audio_tower.') || lower.startsWith('audio_model.')
+    || lower.startsWith('audio.') || lower.startsWith('model.audio.')
+    || lower.startsWith('audio_encoder.')) {
+    return 'audio';
+  }
+
+  // Multimodal: projector tensors
+  if (lower.startsWith('multi_modal_projector.') || lower.startsWith('model.multi_modal_projector.')
+    || lower.startsWith('mm_projector.') || lower.startsWith('model.mm_projector.')) {
+    return 'projector';
+  }
+
   if (lower.includes('shared_expert') || /experts?[._]/.test(lower)) {
     return 'expert';
   }
@@ -207,6 +236,9 @@ export function getGroupType(groupId, modelType) {
   }
   if (groupId === 'embed') return 'embed';
   if (groupId === 'head') return 'head';
+  if (groupId === 'vision') return 'vision';
+  if (groupId === 'projector') return 'projector';
+  if (groupId === 'audio') return 'audio';
   if (groupId === 'other') return 'layer';
 
   if (groupId.includes('.expert.')) return 'expert';

package/src/gpu/kernel-runtime.js

@@ -2,13 +2,15 @@
 
 import { autoTuneKernels, prewarmKernels, clearKernelCaches } from './kernels/utils.js';
 import { getRuntimeConfig } from '../config/runtime.js';
-import { DEFAULT_KERNEL_WARMUP_CONFIG } from '../config/schema/kernel-warmup.schema.js';
 
 
 export async function prepareKernelRuntime(
   options = {}
 ) {
-  const kernelWarmup = getRuntimeConfig().shared?.kernelWarmup ?? DEFAULT_KERNEL_WARMUP_CONFIG;
+  const kernelWarmup = getRuntimeConfig().shared?.kernelWarmup;
+  if (!kernelWarmup) {
+    throw new Error('runtime.shared.kernelWarmup is required but missing from resolved config');
+  }
   const {
     prewarm = kernelWarmup.prewarm,
     prewarmMode = kernelWarmup.prewarmMode,

package/src/gpu/kernels/attention.js

@@ -513,9 +513,10 @@ function resolveAttentionPlan(
         useF16KV,
         useF16Q,
         numHeads,
+        headDim,
         kvLen,
+        isPaged,
         caps,
-        headDim,
         sharedLimit
       );
       const workgroups = calculateAttentionWorkgroups(adaptiveSelection.tier, seqLen, numHeads);

package/src/gpu/kernels/dequant_f16_out.wgsl

@@ -113,9 +113,11 @@ fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
 @compute @workgroup_size(WORKGROUP_SIZE_MAIN, 1, 1)
 fn main(
     @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) num_wg: vec3<u32>
 ) {
-    let block_idx = workgroup_id.x;
+    // Support 2D dispatch for tensors with >65535 blocks.
+    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
     let elem_idx = local_id.x;
 
     if (block_idx >= u.num_blocks) {

package/src/gpu/kernels/dequant_f16_out_vec4.wgsl

@@ -106,9 +106,12 @@ fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
 @compute @workgroup_size(WORKGROUP_SIZE_VEC4, 1, 1)
 fn main_vec4(
     @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) num_wg: vec3<u32>
 ) {
-    let block_idx = workgroup_id.x;
+    // Support 2D dispatch for tensors with >65535 blocks (e.g. large FFN weights).
+    // block_idx = flat workgroup index across both X and Y dimensions.
+    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
     let thread_idx = local_id.x;
 
     if (block_idx >= u.num_blocks) {

package/src/gpu/kernels/dequant_shared.wgsl

@@ -115,9 +115,11 @@ fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
 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>
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) num_wg: vec3<u32>
 ) {
-    let block_idx = workgroup_id.x;
+    // Support 2D dispatch for tensors with >65535 blocks.
+    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
     let elem_idx = local_id.x;
 
     if (block_idx >= u.num_blocks) {

package/src/gpu/kernels/dequant_shared_vec4.wgsl

@@ -108,9 +108,11 @@ fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
 @compute @workgroup_size(WORKGROUP_SIZE_VEC4, 1, 1)
 fn main_vec4(
     @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) num_wg: vec3<u32>
 ) {
-    let block_idx = workgroup_id.x;
+    // Support 2D dispatch for tensors with >65535 blocks.
+    let block_idx = workgroup_id.x + workgroup_id.y * num_wg.x;
     let thread_idx = local_id.x;
 
     if (block_idx >= u.num_blocks) {

package/src/gpu/kernels/dequant_subgroup.wgsl

@@ -118,11 +118,15 @@ fn get_q4(qs: array<u32, 32>, idx: u32) -> u32 {
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(
     @builtin(global_invocation_id) global_id: vec3<u32>,
+    @builtin(num_workgroups) num_wg: vec3<u32>,
     @builtin(subgroup_invocation_id) sg_id: u32,
     @builtin(subgroup_size) sg_size: u32
 ) {
-    let block_idx = global_id.x / QK_K;
-    let elem_idx = global_id.x % QK_K;
+    // Support 2D dispatch for tensors with >65535 workgroups.
+    // Compute flat global thread id across both X and Y dimensions.
+    let flat_global_x = global_id.x + global_id.y * num_wg.x * WORKGROUP_SIZE;
+    let block_idx = flat_global_x / QK_K;
+    let elem_idx = flat_global_x % QK_K;
 
     // Use block 0 for out-of-bounds threads to maintain uniform control flow
     // (required for subgroup operations)

package/src/gpu/kernels/gated-short-conv.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LFM2 gated short convolution kernel.
+ *
+ * Fuses B*x pre-gating, depthwise causal conv1d, and C*conv_out post-gating
+ * into a single GPU dispatch. Each thread handles one channel across all tokens
+ * sequentially, maintaining persistent conv state for autoregressive decode.
+ */
+
+/** Per-layer state maintained between calls. */
+export interface GatedShortConvLayerState {
+  /** Pre-dequantized conv1d weights as GPUBuffer, shape [hiddenSize, kernelSize]. */
+  convWeightGPU: GPUBuffer;
+
+  /** Persistent conv state as GPUBuffer, shape [hiddenSize, kernelSize - 1]. */
+  convStateGPU: GPUBuffer;
+
+  /** Number of channels (hidden dimension). */
+  hiddenSize: number;
+
+  /** Conv1d kernel width (e.g., 4). */
+  kernelSize: number;
+}
+
+/** Tensor returned by the kernel. */
+export interface Tensor {
+  buffer: GPUBuffer;
+  dtype: string;
+  shape: readonly number[];
+  label: string;
+}
+
+/** Options for runGatedShortConvGPU. */
+export interface GatedShortConvOptions {
+  /** Number of tokens in this batch. Required. */
+  numTokens?: number;
+
+  /** Layer index for labeling/tracing. */
+  layerIdx?: number;
+
+  /** Command recorder for batched submission. */
+  recorder?: {
+    getEncoder(): GPUCommandEncoder;
+    trackTemporaryBuffer(buffer: GPUBuffer): void;
+    beginComputePass(label: string): GPUComputePassEncoder;
+    createUniformBuffer(data: ArrayBuffer, label: string): GPUBuffer;
+    device: GPUDevice;
+  } | null;
+}
+
+/**
+ * Run the LFM2 gated short convolution on GPU.
+ *
+ * @param inputTensor Tensor with shape [numTokens, 3 * hiddenSize] containing
+ *   concatenated B, C, x from in_proj matmul output.
+ * @param layerState Persistent per-layer state (conv weights + conv state buffer).
+ * @param options Dispatch options.
+ * @returns Output tensor with shape [numTokens, hiddenSize].
+ */
+export function runGatedShortConvGPU(
+  inputTensor: Tensor,
+  layerState: GatedShortConvLayerState,
+  options?: GatedShortConvOptions
+): Promise<Tensor>;

package/src/gpu/kernels/gated-short-conv.js

@@ -0,0 +1,284 @@
+import { getDevice, getDeviceEpoch } from '../device.js';
+import { WORKGROUP_SIZES } from './constants.js';
+import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
+import { createTensor } from '../tensor.js';
+import {
+  createUniformBufferFromData,
+  getOrCreateBindGroupLayout,
+  getOrCreatePipelineLayout,
+} from './utils.js';
+import { recordDispatch } from './dispatch.js';
+
+const CONV_WORKGROUP_SIZE = WORKGROUP_SIZES.DEFAULT;
+
+const SHADER = /* wgsl */ `
+override WORKGROUP_SIZE: u32 = 256u;
+
+struct Params {
+  num_tokens: u32,
+  hidden_size: u32,
+  kernel_size: u32,
+  _pad: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> input: array<f32>;
+@group(0) @binding(2) var<storage, read> conv_weight: array<f32>;
+@group(0) @binding(3) var<storage, read_write> conv_state: array<f32>;
+@group(0) @binding(4) var<storage, read_write> output: array<f32>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let channel = gid.x;
+  if (channel >= params.hidden_size) {
+    return;
+  }
+
+  let hidden_size = params.hidden_size;
+  let kernel_size = params.kernel_size;
+  let state_width = kernel_size - 1u;
+  let row_stride = 3u * hidden_size;
+  let state_base = channel * state_width;
+  let weight_base = channel * kernel_size;
+
+  for (var t: u32 = 0u; t < params.num_tokens; t = t + 1u) {
+    let row_offset = t * row_stride;
+
+    let b_val = input[row_offset + channel];
+    let c_val = input[row_offset + hidden_size + channel];
+    let x_val = input[row_offset + 2u * hidden_size + channel];
+
+    let bx = b_val * x_val;
+
+    var conv_sum: f32 = 0.0;
+    for (var k: u32 = 0u; k < state_width; k = k + 1u) {
+      conv_sum = conv_sum + conv_state[state_base + k] * conv_weight[weight_base + k];
+    }
+    conv_sum = conv_sum + bx * conv_weight[weight_base + state_width];
+
+    for (var k: u32 = 0u; k + 1u < state_width; k = k + 1u) {
+      conv_state[state_base + k] = conv_state[state_base + k + 1u];
+    }
+    if (state_width > 0u) {
+      conv_state[state_base + state_width - 1u] = bx;
+    }
+
+    output[t * hidden_size + channel] = c_val * conv_sum;
+  }
+}
+`;
+
+// ======================================================================
+// UNIFORM BUFFER
+// ======================================================================
+
+const UNIFORM_LAYOUT = {
+  numTokens: { offset: 0, size: 4 },
+  hiddenSize: { offset: 4, size: 4 },
+  kernelSize: { offset: 8, size: 4 },
+  _pad: { offset: 12, size: 4 },
+};
+
+const UNIFORM_SIZE = 16;
+
+function buildParamsData(numTokens, hiddenSize, kernelSize) {
+  const data = new ArrayBuffer(UNIFORM_SIZE);
+  const view = new DataView(data);
+  view.setUint32(UNIFORM_LAYOUT.numTokens.offset, numTokens, true);
+  view.setUint32(UNIFORM_LAYOUT.hiddenSize.offset, hiddenSize, true);
+  view.setUint32(UNIFORM_LAYOUT.kernelSize.offset, kernelSize, true);
+  view.setUint32(UNIFORM_LAYOUT._pad.offset, 0, true);
+  return data;
+}
+
+// ======================================================================
+// PIPELINE CACHE
+// ======================================================================
+
+let cachedEpoch = -1;
+let pipeline = null;
+let bindGroupLayout = null;
+
+function createPipeline(device) {
+  bindGroupLayout = getOrCreateBindGroupLayout(
+    'gated_short_conv_layout',
+    [
+      { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+      { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+      { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+      { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+      { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+    ],
+    device
+  );
+
+  const module = device.createShaderModule({
+    label: 'gated_short_conv',
+    code: SHADER,
+  });
+
+  pipeline = device.createComputePipeline({
+    label: 'gated_short_conv_pipeline',
+    layout: getOrCreatePipelineLayout('gated_short_conv_pipeline_layout', [bindGroupLayout], device),
+    compute: {
+      module,
+      entryPoint: 'main',
+      constants: {
+        WORKGROUP_SIZE: CONV_WORKGROUP_SIZE,
+      },
+    },
+  });
+}
+
+function ensurePipeline(device) {
+  const epoch = getDeviceEpoch();
+  if (epoch !== cachedEpoch || !pipeline) {
+    createPipeline(device);
+    cachedEpoch = epoch;
+  }
+}
+
+// ======================================================================
+// VALIDATION
+// ======================================================================
+
+function requireGpuBuffer(buffer, label) {
+  if (!(buffer instanceof GPUBuffer)) {
+    throw new Error(`gated_short_conv kernel requires GPUBuffer for ${label}.`);
+  }
+}
+
+// ======================================================================
+// DISPATCH
+// ======================================================================
+
+export async function runGatedShortConvGPU(inputTensor, layerState, options = {}) {
+  const device = getDevice();
+  if (!device) {
+    throw new Error('No GPU device available for gated_short_conv.');
+  }
+
+  const recorder = options.recorder ?? null;
+  const useRecorder = recorder
+    && typeof recorder.getEncoder === 'function'
+    && typeof recorder.trackTemporaryBuffer === 'function';
+
+  requireGpuBuffer(inputTensor?.buffer, 'inputTensor');
+  requireGpuBuffer(layerState?.convWeightGPU, 'convWeightGPU');
+  requireGpuBuffer(layerState?.convStateGPU, 'convStateGPU');
+
+  const numTokens = Number(options.numTokens ?? 0);
+  if (!Number.isFinite(numTokens) || numTokens <= 0) {
+    throw new Error('runGatedShortConvGPU requires numTokens > 0.');
+  }
+
+  const hiddenSize = Number(layerState.hiddenSize ?? 0);
+  if (!Number.isFinite(hiddenSize) || hiddenSize <= 0) {
+    throw new Error('runGatedShortConvGPU requires hiddenSize > 0.');
+  }
+
+  const kernelSize = Number(layerState.kernelSize ?? 0);
+  if (!Number.isFinite(kernelSize) || kernelSize < 2) {
+    throw new Error('runGatedShortConvGPU requires kernelSize >= 2.');
+  }
+
+  ensurePipeline(device);
+
+  const outputSize = numTokens * hiddenSize * Float32Array.BYTES_PER_ELEMENT;
+  const outputBuffer = acquireBuffer(outputSize, undefined, `L${options.layerIdx ?? 0}.gated_short_conv_out`);
+
+  if (useRecorder) {
+    const paramsBuffer = createUniformBufferFromData(
+      'gated_short_conv_params',
+      buildParamsData(numTokens, hiddenSize, kernelSize),
+      recorder
+    );
+
+    try {
+      const bg = device.createBindGroup({
+        label: 'gated_short_conv_bind_group',
+        layout: bindGroupLayout,
+        entries: [
+          { binding: 0, resource: { buffer: paramsBuffer } },
+          { binding: 1, resource: { buffer: inputTensor.buffer } },
+          { binding: 2, resource: { buffer: layerState.convWeightGPU } },
+          { binding: 3, resource: { buffer: layerState.convStateGPU } },
+          { binding: 4, resource: { buffer: outputBuffer } },
+        ],
+      });
+
+      recordDispatch(
+        recorder,
+        pipeline,
+        bg,
+        [Math.ceil(hiddenSize / CONV_WORKGROUP_SIZE), 1, 1],
+        'gated_short_conv'
+      );
+
+      return createTensor(
+        outputBuffer,
+        'f32',
+        [numTokens, hiddenSize],
+        `L${options.layerIdx ?? 0}.gated_short_conv`
+      );
+    } catch (error) {
+      releaseBuffer(outputBuffer);
+      throw error;
+    }
+  }
+
+  // Non-recorder path
+  const paramsBuffer = createUniformBufferFromData(
+    'gated_short_conv_params',
+    buildParamsData(numTokens, hiddenSize, kernelSize),
+    null,
+    device,
+    { useCache: false }
+  );
+  let submitted = false;
+
+  try {
+    const bg = device.createBindGroup({
+      label: 'gated_short_conv_bind_group',
+      layout: bindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer: paramsBuffer } },
+        { binding: 1, resource: { buffer: inputTensor.buffer } },
+        { binding: 2, resource: { buffer: layerState.convWeightGPU } },
+        { binding: 3, resource: { buffer: layerState.convStateGPU } },
+        { binding: 4, resource: { buffer: outputBuffer } },
+      ],
+    });
+
+    const encoder = device.createCommandEncoder({ label: 'gated_short_conv' });
+    const pass = encoder.beginComputePass({ label: 'gated_short_conv_pass' });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bg);
+    pass.dispatchWorkgroups(Math.ceil(hiddenSize / CONV_WORKGROUP_SIZE), 1, 1);
+    pass.end();
+    device.queue.submit([encoder.finish()]);
+    submitted = true;
+
+    return createTensor(
+      outputBuffer,
+      'f32',
+      [numTokens, hiddenSize],
+      `L${options.layerIdx ?? 0}.gated_short_conv`
+    );
+  } catch (error) {
+    releaseBuffer(outputBuffer);
+    throw error;
+  } finally {
+    if (submitted) {
+      device.queue.onSubmittedWorkDone()
+        .then(() => {
+          paramsBuffer.destroy();
+        })
+        .catch(() => {
+          paramsBuffer.destroy();
+        });
+    } else {
+      paramsBuffer.destroy();
+    }
+  }
+}