@simulatte/doppler 0.1.5 → 0.1.7

package/src/gpu/kernels/rope.wgsl

@@ -26,8 +26,8 @@ struct Uniforms {
     start_pos: u32,        // Starting position (for decode)
     rope_base: f32,        // Base frequency (default 10000)
     rope_scale: f32,       // Scaling factor for extended context
-    _pad0: u32,
-    _pad1: u32,
+    rotary_dim: u32,       // Rotary slice within head_dim
+    interleaved: u32,      // 1 = adjacent pairs, 0 = rotate-half
 }
 
 @group(0) @binding(0) var<uniform> u: Uniforms;
@@ -46,7 +46,8 @@ fn main(
     let start_pos = u.start_pos;
 
     // Global thread index (one thread per complex pair)
-    let half_dim = head_dim / 2u;
+    let rotary_dim = u.rotary_dim;
+    let half_dim = rotary_dim / 2u;
     let total_pairs = seq_len * num_heads * half_dim;
     let idx = global_id.x;
 
@@ -68,16 +69,18 @@ fn main(
 
     // Apply "rotate-half" layout: pair (x[i], x[i + half_dim])
     let base_idx = pos * num_heads * head_dim + head_idx * head_dim;
-    let x0 = input[base_idx + pair_idx];
-    let x1 = input[base_idx + pair_idx + half_dim];
+    let first_idx = select(pair_idx, pair_idx * 2u, u.interleaved == 1u);
+    let second_idx = select(pair_idx + half_dim, pair_idx * 2u + 1u, u.interleaved == 1u);
+    let x0 = input[base_idx + first_idx];
+    let x1 = input[base_idx + second_idx];
 
     // Apply rotation
     let y0 = x0 * cos_val - x1 * sin_val;
     let y1 = x0 * sin_val + x1 * cos_val;
 
     // Write back
-    input[base_idx + pair_idx] = y0;
-    input[base_idx + pair_idx + half_dim] = y1;
+    input[base_idx + first_idx] = y0;
+    input[base_idx + second_idx] = y1;
 }
 
 // Compute frequencies on-the-fly (no precomputation needed)
@@ -91,9 +94,10 @@ fn rope_compute_freqs(
     let start_pos = u.start_pos;
     let rope_base = u.rope_base;
     let rope_scale = u.rope_scale;
+    let rotary_dim = u.rotary_dim;
 
     let idx = global_id.x;
-    let half_dim = head_dim / 2u;
+    let half_dim = rotary_dim / 2u;
     let total_pairs = seq_len * num_heads * half_dim;
 
     if (idx >= total_pairs) {
@@ -109,7 +113,7 @@ fn rope_compute_freqs(
     let actual_pos = f32(start_pos + pos) / rope_scale;
 
     // Compute frequency: 1 / (base^(2*pair_idx/head_dim))
-    let exponent = f32(pair_idx * 2u) / f32(head_dim);
+    let exponent = f32(pair_idx * 2u) / f32(rotary_dim);
     let freq = 1.0 / pow(rope_base, exponent);
     let theta = actual_pos * freq;
 
@@ -118,12 +122,14 @@ fn rope_compute_freqs(
 
     // Apply "rotate-half" layout: pair (x[i], x[i + half_dim])
     let base_idx = pos * num_heads * head_dim + head_idx * head_dim;
-    let x0 = input[base_idx + pair_idx];
-    let x1 = input[base_idx + pair_idx + half_dim];
+    let first_idx = select(pair_idx, pair_idx * 2u, u.interleaved == 1u);
+    let second_idx = select(pair_idx + half_dim, pair_idx * 2u + 1u, u.interleaved == 1u);
+    let x0 = input[base_idx + first_idx];
+    let x1 = input[base_idx + second_idx];
 
     // Apply rotation
-    input[base_idx + pair_idx] = x0 * cos_val - x1 * sin_val;
-    input[base_idx + pair_idx + half_dim] = x0 * sin_val + x1 * cos_val;
+    input[base_idx + first_idx] = x0 * cos_val - x1 * sin_val;
+    input[base_idx + second_idx] = x0 * sin_val + x1 * cos_val;
 }
 
 // Apply RoPE to both Q and K in one pass
@@ -138,10 +144,11 @@ fn rope_qk(
     let start_pos = u.start_pos;
     let rope_base = u.rope_base;
     let rope_scale = u.rope_scale;
+    let rotary_dim = u.rotary_dim;
 
     let idx = global_id.x;
     // Each thread handles one Q-K pair at one dimension pair
-    let half_dim = head_dim / 2u;
+    let half_dim = rotary_dim / 2u;
     let total_pairs = seq_len * num_heads * half_dim;
 
     if (idx >= total_pairs) {
@@ -156,7 +163,7 @@ fn rope_qk(
     let actual_pos = f32(start_pos + pos) / rope_scale;
 
     // Compute frequency
-    let exponent = f32(pair_idx * 2u) / f32(head_dim);
+    let exponent = f32(pair_idx * 2u) / f32(rotary_dim);
     let freq = 1.0 / pow(rope_base, exponent);
     let theta = actual_pos * freq;
 
@@ -168,16 +175,18 @@ fn rope_qk(
     let k_base_idx = q_base_idx + head_dim;  // K starts after Q
 
     // Process Q
-    let q0 = input[q_base_idx + pair_idx];
-    let q1 = input[q_base_idx + pair_idx + half_dim];
-    input[q_base_idx + pair_idx] = q0 * cos_val - q1 * sin_val;
-    input[q_base_idx + pair_idx + half_dim] = q0 * sin_val + q1 * cos_val;
+    let first_idx = select(pair_idx, pair_idx * 2u, u.interleaved == 1u);
+    let second_idx = select(pair_idx + half_dim, pair_idx * 2u + 1u, u.interleaved == 1u);
+    let q0 = input[q_base_idx + first_idx];
+    let q1 = input[q_base_idx + second_idx];
+    input[q_base_idx + first_idx] = q0 * cos_val - q1 * sin_val;
+    input[q_base_idx + second_idx] = q0 * sin_val + q1 * cos_val;
 
     // Process K
-    let k0 = input[k_base_idx + pair_idx];
-    let k1 = input[k_base_idx + pair_idx + half_dim];
-    input[k_base_idx + pair_idx] = k0 * cos_val - k1 * sin_val;
-    input[k_base_idx + pair_idx + half_dim] = k0 * sin_val + k1 * cos_val;
+    let k0 = input[k_base_idx + first_idx];
+    let k1 = input[k_base_idx + second_idx];
+    input[k_base_idx + first_idx] = k0 * cos_val - k1 * sin_val;
+    input[k_base_idx + second_idx] = k0 * sin_val + k1 * cos_val;
 }
 
 // Precompute frequency table (run once at init)
@@ -190,9 +199,10 @@ fn precompute_freqs(
     let seq_len = u.seq_len;  // maxSeqLen for precomputation
     let rope_base = u.rope_base;
     let rope_scale = u.rope_scale;
+    let rotary_dim = u.rotary_dim;
 
     let idx = global_id.x;
-    let half_dim = head_dim / 2u;
+    let half_dim = rotary_dim / 2u;
     let total_elements = seq_len * half_dim;
 
     if (idx >= total_elements) {
@@ -203,7 +213,7 @@ fn precompute_freqs(
     let dim_idx = idx % half_dim;
 
     let actual_pos = f32(pos) / rope_scale;
-    let exponent = f32(dim_idx * 2u) / f32(head_dim);
+    let exponent = f32(dim_idx * 2u) / f32(rotary_dim);
     let freq = 1.0 / pow(rope_base, exponent);
     let theta = actual_pos * freq;
 
@@ -218,6 +228,7 @@ fn rope_ntk_scaled(
     @builtin(global_invocation_id) global_id: vec3<u32>
 ) {
     let head_dim = u.head_dim;
+    let rotary_dim = u.rotary_dim;
     let num_heads = u.num_heads;
     let seq_len = u.seq_len;
     let start_pos = u.start_pos;
@@ -225,7 +236,7 @@ fn rope_ntk_scaled(
     let rope_scale = u.rope_scale;
 
     let idx = global_id.x;
-    let half_dim = head_dim / 2u;
+    let half_dim = rotary_dim / 2u;
     let total_pairs = seq_len * num_heads * half_dim;
 
     if (idx >= total_pairs) {
@@ -234,7 +245,7 @@ fn rope_ntk_scaled(
 
     // NTK scaling: increase base proportionally to scale factor
     // This preserves high-frequency components better than linear interpolation
-    rope_base = rope_base * pow(rope_scale, f32(head_dim) / (f32(head_dim) - 2.0));
+    rope_base = rope_base * pow(rope_scale, f32(rotary_dim) / (f32(rotary_dim) - 2.0));
 
     let pos = idx / (num_heads * half_dim);
     let remainder = idx % (num_heads * half_dim);
@@ -243,7 +254,7 @@ fn rope_ntk_scaled(
 
     let actual_pos = f32(start_pos + pos);
 
-    let exponent = f32(pair_idx * 2u) / f32(head_dim);
+    let exponent = f32(pair_idx * 2u) / f32(rotary_dim);
     let freq = 1.0 / pow(rope_base, exponent);
     let theta = actual_pos * freq;
 
@@ -251,11 +262,13 @@ fn rope_ntk_scaled(
     let sin_val = sin(theta);
 
     let base_idx = pos * num_heads * head_dim + head_idx * head_dim;
-    let x0 = input[base_idx + pair_idx];
-    let x1 = input[base_idx + pair_idx + half_dim];
+    let first_idx = select(pair_idx, pair_idx * 2u, u.interleaved == 1u);
+    let second_idx = select(pair_idx + half_dim, pair_idx * 2u + 1u, u.interleaved == 1u);
+    let x0 = input[base_idx + first_idx];
+    let x1 = input[base_idx + second_idx];
 
-    input[base_idx + pair_idx] = x0 * cos_val - x1 * sin_val;
-    input[base_idx + pair_idx + half_dim] = x0 * sin_val + x1 * cos_val;
+    input[base_idx + first_idx] = x0 * cos_val - x1 * sin_val;
+    input[base_idx + second_idx] = x0 * sin_val + x1 * cos_val;
 }
 
 // YaRN-style RoPE with attention scaling
@@ -265,6 +278,7 @@ fn rope_yarn(
     @builtin(global_invocation_id) global_id: vec3<u32>
 ) {
     let head_dim = u.head_dim;
+    let rotary_dim = u.rotary_dim;
     let num_heads = u.num_heads;
     let seq_len = u.seq_len;
     let start_pos = u.start_pos;
@@ -272,7 +286,7 @@ fn rope_yarn(
     let rope_scale = u.rope_scale;
 
     let idx = global_id.x;
-    let half_dim = head_dim / 2u;
+    let half_dim = rotary_dim / 2u;
     let total_pairs = seq_len * num_heads * half_dim;
 
     if (idx >= total_pairs) {
@@ -292,7 +306,7 @@ fn rope_yarn(
     let alpha: f32 = 1.0;
 
     // Compute original frequency
-    let exponent = f32(pair_idx * 2u) / f32(head_dim);
+    let exponent = f32(pair_idx * 2u) / f32(rotary_dim);
     let orig_freq = 1.0 / pow(rope_base, exponent);
 
     // Compute wavelength
@@ -300,8 +314,8 @@ fn rope_yarn(
 
     // Interpolation factor based on wavelength
     var ramp: f32;
-    let low_wavelength = f32(head_dim) / beta_fast;
-    let high_wavelength = f32(head_dim) / beta_slow;
+    let low_wavelength = f32(rotary_dim) / beta_fast;
+    let high_wavelength = f32(rotary_dim) / beta_slow;
 
     if (wavelength < low_wavelength) {
         ramp = 0.0;  // No interpolation for high frequencies
@@ -320,9 +334,11 @@ fn rope_yarn(
     let sin_val = sin(theta);
 
     let base_idx = pos * num_heads * head_dim + head_idx * head_dim;
-    let x0 = input[base_idx + pair_idx];
-    let x1 = input[base_idx + pair_idx + half_dim];
+    let first_idx = select(pair_idx, pair_idx * 2u, u.interleaved == 1u);
+    let second_idx = select(pair_idx + half_dim, pair_idx * 2u + 1u, u.interleaved == 1u);
+    let x0 = input[base_idx + first_idx];
+    let x1 = input[base_idx + second_idx];
 
-    input[base_idx + pair_idx] = x0 * cos_val - x1 * sin_val;
-    input[base_idx + pair_idx + half_dim] = x0 * sin_val + x1 * cos_val;
+    input[base_idx + first_idx] = x0 * cos_val - x1 * sin_val;
+    input[base_idx + second_idx] = x0 * sin_val + x1 * cos_val;
 }

package/src/gpu/kernels/sample.js

@@ -1,7 +1,7 @@
 
 
 import { getDevice, getKernelCapabilities } from '../device.js';
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
+import { acquireBuffer, readBufferSlice, releaseBuffer } from '../../memory/buffer-pool.js';
 import { WORKGROUP_SIZES } from './constants.js';
 import { createPipeline, createUniformBufferWithView, getOrCreateBindGroupLayout } from './utils.js';
 import { allowReadback } from '../perf-guards.js';
@@ -156,18 +156,19 @@ function ensureOutputBufferSize(outputBuffer, minBytes, label) {
   }
 }
 
-function readTokenFromOutput(device, outputBuffer, outputIndex, label) {
-  const stagingBuffer = device.createBuffer({
-    label,
-    size: 4,
-    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-  });
-
-  const copyEncoder = device.createCommandEncoder({ label: `${label}_copy` });
-  copyEncoder.copyBufferToBuffer(outputBuffer, outputIndex * 4, stagingBuffer, 0, 4);
-  device.queue.submit([copyEncoder.finish()]);
+async function readTokenFromOutput(outputBuffer, outputIndex) {
+  return new Uint32Array(await readBufferSlice(outputBuffer, outputIndex * 4, 4))[0];
+}
 
-  return stagingBuffer;
+function cleanupRunResources(uniformBuffer, ownedBuffers) {
+  if (uniformBuffer) {
+    uniformBuffer.destroy();
+  }
+  for (const buffer of ownedBuffers) {
+    if (buffer) {
+      releaseBuffer(buffer);
+    }
+  }
 }
 
 async function executeArgmaxRun(logits, vocabSize, options) {
@@ -238,20 +239,14 @@ async function executeArgmaxRun(logits, vocabSize, options) {
 
   device.queue.submit([encoder.finish()]);
 
-  const stagingBuffer = readTokenFromOutput(device, outputBuffer, outputIndex, 'argmax_staging');
-  await stagingBuffer.mapAsync(GPUMapMode.READ);
-  const tokenId = new Uint32Array(stagingBuffer.getMappedRange())[0];
-  stagingBuffer.unmap();
-
-  stagingBuffer.destroy();
-  uniformBuffer.destroy();
-  releaseBuffer(tempLogits);
-  releaseBuffer(tempIndices);
-  if (ownsOutputBuffer) {
-    releaseBuffer(outputBuffer);
+  try {
+    return await readTokenFromOutput(outputBuffer, outputIndex);
+  } finally {
+    cleanupRunResources(
+      uniformBuffer,
+      [tempLogits, tempIndices, ownsOutputBuffer ? outputBuffer : null]
+    );
   }
-
-  return tokenId;
 }
 
 async function executeArgmaxRecord(recorder, logits, vocabSize, options) {
@@ -428,20 +423,14 @@ export async function runGPUSample(
 
   device.queue.submit([encoder.finish()]);
 
-  const stagingBuffer = readTokenFromOutput(device, outputBuffer, outputIndex, 'sample_staging');
-  await stagingBuffer.mapAsync(GPUMapMode.READ);
-  const tokenId = new Uint32Array(stagingBuffer.getMappedRange())[0];
-  stagingBuffer.unmap();
-
-  stagingBuffer.destroy();
-  uniformBuffer.destroy();
-  releaseBuffer(topkLogits);
-  releaseBuffer(topkIndices);
-  if (ownsOutputBuffer) {
-    releaseBuffer(outputBuffer);
+  try {
+    return await readTokenFromOutput(outputBuffer, outputIndex);
+  } finally {
+    cleanupRunResources(
+      uniformBuffer,
+      [topkLogits, topkIndices, ownsOutputBuffer ? outputBuffer : null]
+    );
   }
-
-  return tokenId;
 }
 
 

package/src/gpu/kernels/sana_linear_attention.js

@@ -29,7 +29,6 @@ async function runSummary(target, query, key, value, summaryBuffer, uniforms, va
 }
 
 async function runApply(target, query, summaryBuffer, outputBuffer, uniforms, variant) {
-  const outputSize = uniforms.num_tokens * uniforms.hidden_size;
   await unifiedKernelWrapper(
     'sana_linear_attention_apply',
     target,
@@ -45,7 +44,7 @@ async function runApply(target, query, summaryBuffer, outputBuffer, uniforms, va
       _pad1: 0,
       _pad2: 0,
     },
-    Math.ceil(outputSize / WORKGROUP_SIZES.DEFAULT)
+    [Math.ceil(uniforms.hidden_size / WORKGROUP_SIZES.DEFAULT), uniforms.num_tokens, 1]
   );
 }
 
@@ -65,6 +64,8 @@ async function _sanaLinearAttention(target, query, key, value, options = {}) {
     outputBuffer = null,
     summaryBuffer = null,
   } = options;
+  const ownsSummary = summaryBuffer == null;
+  const ownsOutput = outputBuffer == null;
 
   if (
     !Number.isFinite(numHeads) ||
@@ -99,18 +100,24 @@ async function _sanaLinearAttention(target, query, key, value, options = {}) {
     eps,
   };
 
-  await runSummary(target, query, key, value, temporarySummary, uniforms, variant);
-  await runApply(target, query, temporarySummary, output, uniforms, variant);
-
-  if (!summaryBuffer) {
-    if (recorder) {
-      recorder.trackTemporaryBuffer(temporarySummary);
-    } else {
-      releaseBuffer(temporarySummary);
+  try {
+    await runSummary(target, query, key, value, temporarySummary, uniforms, variant);
+    await runApply(target, query, temporarySummary, output, uniforms, variant);
+    return createTensor(output, query.dtype, [numTokens, hiddenSize], 'sana_linear_attention_output');
+  } catch (error) {
+    if (ownsOutput) {
+      releaseBuffer(output);
+    }
+    throw error;
+  } finally {
+    if (ownsSummary) {
+      if (recorder) {
+        recorder.trackTemporaryBuffer(temporarySummary);
+      } else {
+        releaseBuffer(temporarySummary);
+      }
     }
   }
-
-  return createTensor(output, query.dtype, [numTokens, hiddenSize], 'sana_linear_attention_output');
 }
 
 export async function runSanaLinearAttention(query, key, value, options = {}) {

package/src/gpu/kernels/sana_linear_attention_apply.wgsl

@@ -18,14 +18,13 @@ struct Uniforms {
 
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    let total = u.num_tokens * u.hidden_size;
-    if (idx >= total) {
+    let hidden = gid.x;
+    let token = gid.y;
+    if (token >= u.num_tokens || hidden >= u.hidden_size) {
         return;
     }
 
-    let token = idx / u.hidden_size;
-    let hidden = idx - token * u.hidden_size;
+    let idx = token * u.hidden_size + hidden;
     let head = hidden / u.head_dim;
     let dim = hidden - head * u.head_dim;
     let rows_per_head = u.head_dim + 1u;

package/src/gpu/kernels/sana_linear_attention_apply_f16.wgsl

@@ -20,14 +20,13 @@ struct Uniforms {
 
 @compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
 fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    let total = u.num_tokens * u.hidden_size;
-    if (idx >= total) {
+    let hidden = gid.x;
+    let token = gid.y;
+    if (token >= u.num_tokens || hidden >= u.hidden_size) {
         return;
     }
 
-    let token = idx / u.hidden_size;
-    let hidden = idx - token * u.hidden_size;
+    let idx = token * u.hidden_size + hidden;
     let head = hidden / u.head_dim;
     let dim = hidden - head * u.head_dim;
     let rows_per_head = u.head_dim + 1u;

package/src/gpu/kernels/sana_linear_attention_summary.wgsl

@@ -33,6 +33,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 
     var acc: f32 = 0.0;
     for (var token: u32 = 0u; token < u.num_tokens; token = token + 1u) {
+        let query_value = query[token * u.hidden_size + hidden_base + col];
         let key_idx = token * u.hidden_size + hidden_base + col;
         let key_value = max(key[key_idx], 0.0);
         let value_value = select(
@@ -40,6 +41,9 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
             1.0,
             row == u.head_dim
         );
+        if (u.hidden_size == 0u) {
+            acc = acc + query_value;
+        }
         acc = acc + value_value * key_value;
     }
 

package/src/gpu/kernels/sana_linear_attention_summary_f16.wgsl

@@ -35,6 +35,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 
     var acc: f32 = 0.0;
     for (var token: u32 = 0u; token < u.num_tokens; token = token + 1u) {
+        let query_value = f32(query[token * u.hidden_size + hidden_base + col]);
         let key_idx = token * u.hidden_size + hidden_base + col;
         let key_value = max(f32(key[key_idx]), 0.0);
         let value_value = select(
@@ -42,6 +43,9 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
             1.0,
             row == u.head_dim
         );
+        if (u.hidden_size == 0u) {
+            acc = acc + query_value;
+        }
         acc = acc + value_value * key_value;
     }
 

package/src/gpu/kernels/scale.js

@@ -1,4 +1,4 @@
-import { acquireBuffer } from '../../memory/buffer-pool.js';
+import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
 import { createTensor, dtypeBytes } from '../tensor.js';
 import { WORKGROUP_SIZES } from './constants.js';
 import { unifiedKernelWrapper } from './utils.js';
@@ -6,6 +6,7 @@ import { selectRuleValue } from './rule-registry.js';
 
 async function _scale(target, input, scale, options = {}) {
   const { count, outputBuffer = null, inplace = false } = options;
+  const ownsOutput = !inplace && outputBuffer == null;
 
   const bytesPerElement = dtypeBytes(input.dtype);
   const inferredCount = count ?? Math.floor(input.buffer.size / bytesPerElement);
@@ -16,16 +17,22 @@ async function _scale(target, input, scale, options = {}) {
 
   const bindings = inplace ? [outputBuf, outputBuf] : [input, outputBuf];
 
-  await unifiedKernelWrapper(
-    'scale',
-    target,
-    variant,
-    bindings,
-    { size: inferredCount, scale },
-    Math.ceil(inferredCount / WORKGROUP_SIZES.DEFAULT)
-  );
-
-  return createTensor(outputBuf, input.dtype, [...input.shape], 'scale_output');
+  try {
+    await unifiedKernelWrapper(
+      'scale',
+      target,
+      variant,
+      bindings,
+      { size: inferredCount, scale },
+      Math.ceil(inferredCount / WORKGROUP_SIZES.DEFAULT)
+    );
+    return createTensor(outputBuf, input.dtype, [...input.shape], 'scale_output');
+  } catch (error) {
+    if (ownsOutput) {
+      releaseBuffer(outputBuf);
+    }
+    throw error;
+  }
 }
 
 export async function runScale(input, scale, options = {}) {

package/src/gpu/kernels/shader-cache.js

@@ -138,8 +138,10 @@ export async function compileShader(
     code: source,
   });
 
-  // Check for compilation errors
-  const compilationInfo = await module.getCompilationInfo();
+  // Check for compilation errors (getCompilationInfo not available in all WebGPU providers)
+  const compilationInfo = typeof module.getCompilationInfo === 'function'
+    ? await module.getCompilationInfo()
+    : { messages: [] };
   if (compilationInfo.messages.length > 0) {
     for (const msg of compilationInfo.messages) {
       if (msg.type === 'error') {

package/src/gpu/kernels/silu.d.ts

@@ -16,6 +16,7 @@ export interface SiLUOptions extends OutputBufferOptions {
   size?: number | null;
   gate?: Tensor | null;
   gateActivation?: 'silu' | 'sigmoid';
+  inputActivation?: 'silu' | 'identity';
   useVec4?: boolean;
   biasOffset?: number;
   swigluLimit: number | null;