@simulatte/doppler 0.1.7 → 0.1.9

package/src/gpu/kernels/sample.wgsl

@@ -40,6 +40,16 @@ fn apply_softcap(x: f32, softcap: f32) -> f32 {
     return softcap * tanh(x / softcap);
 }
 
+fn candidate_beats(candidate_value: f32, candidate_index: u32, best_value: f32, best_index: u32) -> bool {
+    if (candidate_value > best_value) {
+        return true;
+    }
+    if (candidate_value < best_value) {
+        return false;
+    }
+    return candidate_index < best_index;
+}
+
 @group(0) @binding(0) var<uniform> u: Uniforms;
 @group(0) @binding(1) var<storage, read> logits: array<f32>;              // [vocabSize]
 @group(0) @binding(2) var<storage, read_write> output: array<u32>;         // [N] - selected tokens
@@ -87,7 +97,7 @@ fn find_topk_phase1(
         if (idx != pad_id) {
             // Apply softcapping before temperature scaling
             let val = apply_softcap(logits[idx], softcap) / temperature;
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -103,7 +113,12 @@ fn find_topk_phase1(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -150,7 +165,7 @@ fn find_topk_phase2(
             var max_val = shared_values[k];
 
             for (var i: u32 = k + 1u; i < num_candidates; i = i + 1u) {
-                if (shared_values[i] > max_val) {
+                if (candidate_beats(shared_values[i], shared_indices[i], max_val, shared_indices[max_idx])) {
                     max_val = shared_values[i];
                     max_idx = i;
                 }
@@ -249,7 +264,7 @@ fn sample_single_pass(
         if (idx != pad_id) {
             // Apply softcapping before temperature scaling
             let val = apply_softcap(logits[idx], softcap) / temperature;
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -265,7 +280,12 @@ fn sample_single_pass(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -308,7 +328,7 @@ fn argmax(
         if (idx != pad_id) {
             // Apply softcapping (argmax is greedy, no temperature)
             let val = apply_softcap(logits[idx], softcap);
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -324,7 +344,12 @@ fn argmax(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -362,7 +387,12 @@ fn argmax_reduce(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -374,4 +404,4 @@ fn argmax_reduce(
     if (thread_idx == 0u) {
         output[u.output_index] = shared_indices[0];
     }
-}
+}

package/src/gpu/kernels/sample_f16.wgsl

@@ -34,6 +34,16 @@ fn apply_softcap(x: f32, softcap: f32) -> f32 {
     return softcap * tanh(x / softcap);
 }
 
+fn candidate_beats(candidate_value: f32, candidate_index: u32, best_value: f32, best_index: u32) -> bool {
+    if (candidate_value > best_value) {
+        return true;
+    }
+    if (candidate_value < best_value) {
+        return false;
+    }
+    return candidate_index < best_index;
+}
+
 @group(0) @binding(0) var<uniform> u: Uniforms;
 @group(0) @binding(1) var<storage, read> logits: array<f16>;
 @group(0) @binding(2) var<storage, read_write> output: array<u32>;
@@ -74,7 +84,7 @@ fn find_topk_phase1(
     while (idx < vocab_size) {
         if (idx != pad_id) {
             let val = apply_softcap(f32(logits[idx]), softcap) / temperature;
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -89,7 +99,12 @@ fn find_topk_phase1(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -130,7 +145,7 @@ fn find_topk_phase2(
             var max_val = shared_values[k];
 
             for (var i: u32 = k + 1u; i < num_candidates; i = i + 1u) {
-                if (shared_values[i] > max_val) {
+                if (candidate_beats(shared_values[i], shared_indices[i], max_val, shared_indices[max_idx])) {
                     max_val = shared_values[i];
                     max_idx = i;
                 }
@@ -218,7 +233,7 @@ fn sample_single_pass(
     while (idx < vocab_size) {
         if (idx != pad_id) {
             let val = apply_softcap(f32(logits[idx]), softcap) / temperature;
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -233,7 +248,12 @@ fn sample_single_pass(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -267,7 +287,7 @@ fn argmax(
     while (idx < vocab_size) {
         if (idx != pad_id) {
             let val = apply_softcap(f32(logits[idx]), softcap);
-            if (val > local_max) {
+            if (candidate_beats(val, idx, local_max, local_max_idx)) {
                 local_max = val;
                 local_max_idx = idx;
             }
@@ -282,7 +302,12 @@ fn argmax(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }
@@ -316,7 +341,12 @@ fn argmax_reduce(
     var stride = WORKGROUP_SIZE / 2u;
     while (stride > 0u) {
         if (thread_idx < stride) {
-            if (shared_values[thread_idx + stride] > shared_values[thread_idx]) {
+            if (candidate_beats(
+                shared_values[thread_idx + stride],
+                shared_indices[thread_idx + stride],
+                shared_values[thread_idx],
+                shared_indices[thread_idx]
+            )) {
                 shared_values[thread_idx] = shared_values[thread_idx + stride];
                 shared_indices[thread_idx] = shared_indices[thread_idx + stride];
             }

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

@@ -133,10 +133,15 @@ export async function compileShader(
   source,
   label
 ) {
-  const module = device.createShaderModule({
-    label,
-    code: source,
-  });
+  let module;
+  try {
+    module = device.createShaderModule({
+      label,
+      code: source,
+    });
+  } catch (err) {
+    throw new Error(`createShaderModule failed for "${label}": ${err.message}`);
+  }
 
   // Check for compilation errors (getCompilationInfo not available in all WebGPU providers)
   const compilationInfo = typeof module.getCompilationInfo === 'function'

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

@@ -0,0 +1,50 @@
+/**
+ * Split Q and Gate Kernel
+ *
+ * De-interleaves Q and Gate projections from q_proj output for attentionOutputGate models.
+ * Models like Qwen 3.5 store q_proj weights in per-head interleaved layout:
+ *   rows [h*headDim*2 : h*headDim*2+headDim] = Q for head h
+ *   rows [h*headDim*2+headDim : (h+1)*headDim*2] = Gate for head h
+ * This kernel separates the full matmul output into contiguous Q and Gate tensors.
+ */
+
+import type { Tensor } from '../tensor.js';
+import type { CommandRecorder } from '../command-recorder.js';
+
+/** Split Q and Gate options */
+export interface SplitQGOptions {
+  numTokens: number;
+  numHeads: number;
+  headDim: number;
+  /** Pre-allocated Q output tensor */
+  qTensor?: Tensor | null;
+  /** Pre-allocated Gate output tensor */
+  gTensor?: Tensor | null;
+}
+
+/** Split Q and Gate result */
+export interface SplitQGResult {
+  Q: Tensor;
+  G: Tensor;
+}
+
+/**
+ * De-interleave Q and Gate from q_proj output.
+ *
+ * @param qgTensor - Full q_proj output [numTokens, numHeads * headDim * 2] (interleaved)
+ * @param options - Split configuration
+ * @returns Separate Q and Gate tensors, each [numTokens, numHeads * headDim]
+ */
+export declare function runSplitQG(
+  qgTensor: Tensor,
+  options: SplitQGOptions
+): Promise<SplitQGResult>;
+
+/**
+ * Record split Q and Gate (batched, no submit).
+ */
+export declare function recordSplitQG(
+  recorder: CommandRecorder,
+  qgTensor: Tensor,
+  options: SplitQGOptions
+): Promise<SplitQGResult>;

package/src/gpu/kernels/split_qg.js

@@ -0,0 +1,46 @@
+
+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';
+import { selectRuleValue } from './rule-registry.js';
+
+async function _splitQG(target, qgTensor, options) {
+  const { numTokens, numHeads, headDim, qTensor = null, gTensor = null } = options;
+  const ownsQ = qTensor == null;
+  const ownsG = gTensor == null;
+
+  const outputDtype = qgTensor.dtype;
+  const pipelineVariant = selectRuleValue('splitQg', 'variant', { outputDtype });
+  const bytesPerElement = dtypeBytes(outputDtype);
+  const qSize = numHeads * headDim;
+
+  const qBuffer = qTensor?.buffer || acquireBuffer(numTokens * qSize * bytesPerElement, undefined, 'Q');
+  const gBuffer = gTensor?.buffer || acquireBuffer(numTokens * qSize * bytesPerElement, undefined, 'Q_gate');
+
+  try {
+    await unifiedKernelWrapper(
+      'split_qg', target, pipelineVariant,
+      [qgTensor, qBuffer, gBuffer],
+      { num_tokens: numTokens, num_heads: numHeads, head_dim: headDim, _pad: 0 },
+      Math.ceil((numTokens * qSize) / WORKGROUP_SIZES.DEFAULT)
+    );
+
+    const Q = qTensor || createTensor(qBuffer, outputDtype, [numTokens, qSize], 'Q');
+    const G = gTensor || createTensor(gBuffer, outputDtype, [numTokens, qSize], 'Q_gate');
+
+    return { Q, G };
+  } catch (error) {
+    if (ownsQ) releaseBuffer(qBuffer);
+    if (ownsG) releaseBuffer(gBuffer);
+    throw error;
+  }
+}
+
+export async function runSplitQG(qgTensor, options) {
+  return _splitQG(null, qgTensor, options);
+}
+
+export async function recordSplitQG(recorder, qgTensor, options) {
+  return _splitQG(recorder, qgTensor, options);
+}

package/src/gpu/kernels/split_qg.wgsl

@@ -0,0 +1,58 @@
+// split_qg.wgsl
+
+/**
+ * De-interleave Q and Gate projections from q_proj output for attentionOutputGate models.
+ *
+ * Models like Qwen 3.5 store q_proj weights with interleaved head layout:
+ *   rows [h*headDim*2 : h*headDim*2+headDim]     = Q for head h
+ *   rows [h*headDim*2+headDim : (h+1)*headDim*2] = Gate for head h
+ *
+ * A single full matmul over all 2*qSize rows produces interleaved output:
+ *   input[token, h*headDim*2 : h*headDim*2+headDim]     = Q head h
+ *   input[token, h*headDim*2+headDim : (h+1)*headDim*2] = Gate head h
+ *
+ * This kernel separates them into contiguous Q and G outputs:
+ *   Q[token, h*headDim + dim] = input[token, h*headDim*2 + dim]
+ *   G[token, h*headDim + dim] = input[token, h*headDim*2 + headDim + dim]
+ *
+ * Input layout  (row-major): [numTokens, numHeads * headDim * 2]
+ * Output Q layout (row-major): [numTokens, numHeads * headDim]
+ * Output G layout (row-major): [numTokens, numHeads * headDim]
+ */
+
+struct Params {
+    num_tokens: u32,
+    num_heads: u32,
+    head_dim: u32,
+    _pad: u32,
+}
+
+override WORKGROUP_SIZE: u32 = 256u;
+
+@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_write> Q: array<f32>;
+@group(0) @binding(3) var<storage, read_write> G: array<f32>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    let q_size = params.num_heads * params.head_dim;
+    let total_elements = params.num_tokens * q_size;
+
+    if (idx >= total_elements) {
+        return;
+    }
+
+    let token = idx / q_size;
+    let elem = idx % q_size;
+    let head = elem / params.head_dim;
+    let dim = elem % params.head_dim;
+
+    // Input is interleaved per head: [Q_h (headDim elems), G_h (headDim elems)]
+    let src_q = token * (q_size * 2u) + head * (params.head_dim * 2u) + dim;
+    let src_g = src_q + params.head_dim;
+
+    Q[idx] = input[src_q];
+    G[idx] = input[src_g];
+}

package/src/gpu/kernels/split_qg_f16.wgsl

@@ -0,0 +1,62 @@
+// AUTO-GENERATED from src/gpu/kernels/split_qg.wgsl.
+// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
+// split_qg_f16.wgsl
+
+/**
+ * De-interleave Q and Gate projections from q_proj output for attentionOutputGate models (f16).
+ *
+ * Models like Qwen 3.5 store q_proj weights with interleaved head layout:
+ *   rows [h*headDim*2 : h*headDim*2+headDim]     = Q for head h
+ *   rows [h*headDim*2+headDim : (h+1)*headDim*2] = Gate for head h
+ *
+ * A single full matmul over all 2*qSize rows produces interleaved output:
+ *   input[token, h*headDim*2 : h*headDim*2+headDim]     = Q head h
+ *   input[token, h*headDim*2+headDim : (h+1)*headDim*2] = Gate head h
+ *
+ * This kernel separates them into contiguous Q and G outputs:
+ *   Q[token, h*headDim + dim] = input[token, h*headDim*2 + dim]
+ *   G[token, h*headDim + dim] = input[token, h*headDim*2 + headDim + dim]
+ *
+ * Input layout  (row-major): [numTokens, numHeads * headDim * 2]
+ * Output Q layout (row-major): [numTokens, numHeads * headDim]
+ * Output G layout (row-major): [numTokens, numHeads * headDim]
+ */
+
+enable f16;
+
+struct Params {
+    num_tokens: u32,
+    num_heads: u32,
+    head_dim: u32,
+    _pad: u32,
+}
+
+override WORKGROUP_SIZE: u32 = 256u;
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> input: array<f16>;
+@group(0) @binding(2) var<storage, read_write> Q: array<f16>;
+@group(0) @binding(3) var<storage, read_write> G: array<f16>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    let q_size = params.num_heads * params.head_dim;
+    let total_elements = params.num_tokens * q_size;
+
+    if (idx >= total_elements) {
+        return;
+    }
+
+    let token = idx / q_size;
+    let elem = idx % q_size;
+    let head = elem / params.head_dim;
+    let dim = elem % params.head_dim;
+
+    // Input is interleaved per head: [Q_h (headDim elems), G_h (headDim elems)]
+    let src_q = token * (q_size * 2u) + head * (params.head_dim * 2u) + dim;
+    let src_g = src_q + params.head_dim;
+
+    Q[idx] = input[src_q];
+    G[idx] = input[src_g];
+}

package/src/gpu/weight-buffer.d.ts

@@ -110,6 +110,6 @@ export function getBuffer(weight: GPUBuffer | WeightBuffer | TensorLike): GPUBuf
 export function getLayout(weight: GPUBuffer | WeightBuffer | TensorLike): WeightLayout | null;
 
 /**
- * Get dtype from WeightBuffer, or null for raw GPUBuffer.
+ * Get dtype from WeightBuffer, tagged raw GPUBuffer, or TensorLike.
  */
 export function getWeightDtype(weight: GPUBuffer | WeightBuffer | TensorLike): WeightDtype | TensorLike['dtype'] | null;

package/src/gpu/weight-buffer.js

@@ -114,5 +114,5 @@ export function getLayout(weight) {
 export function getWeightDtype(weight) {
   if (isWeightBuffer(weight)) return weight.dtype;
   if (isTensorLike(weight)) return weight.dtype;
-  return null;
+  return getBufferDtype(weight);
 }

package/src/inference/browser-harness.d.ts

@@ -9,6 +9,7 @@ import type { InferencePipeline } from './pipelines/text.js';
 import type { DiffusionPipeline } from './pipelines/diffusion/pipeline.js';
 import type { EnergyPipeline } from './pipelines/energy/pipeline.js';
 import type { SavedReportInfo, SaveReportOptions } from '../storage/reports.js';
+import type { DebugSnapshot } from '../debug/history.js';
 
 export interface BrowserHarnessOptions extends InferenceHarnessOptions {
   modelUrl: string;
@@ -143,6 +144,7 @@ export interface BrowserSuiteResult extends SuiteSummary {
   output?: string | DiffusionOutput | null;
   deviceInfo?: Record<string, unknown> | null;
   memoryStats?: ReturnType<InferencePipeline['getMemoryStats']> | null;
+  debugSnapshot?: DebugSnapshot | null;
   pipeline?: InferencePipeline | DiffusionPipeline | EnergyPipeline | null;
   report: Record<string, unknown>;
   reportInfo: SavedReportInfo;

package/src/inference/browser-harness.js

@@ -2,6 +2,7 @@
 import { initializeInference } from './test-harness.js';
 import { saveReport } from '../storage/reports.js';
 import { getRuntimeConfig, setRuntimeConfig } from '../config/runtime.js';
+import { clearLogHistory, getDebugSnapshot } from '../debug/history.js';
 import { computeSampleStats } from '../debug/stats.js';
 import {
   setActiveKernelPath,
@@ -846,15 +847,32 @@ async function dispatchBrowserSuite(suite, options) {
   return null;
 }
 
+function shouldCaptureDebugSnapshot(suite, runtimeConfig) {
+  const debug = runtimeConfig?.shared?.debug ?? {};
+  const logLevel = String(debug.logLevel?.defaultLogLevel ?? '').toLowerCase();
+  return suite === 'debug'
+    || debug.trace?.enabled === true
+    || debug.pipeline?.enabled === true
+    || (Array.isArray(debug.probes) && debug.probes.length > 0)
+    || debug.profiler?.enabled === true
+    || logLevel === 'debug'
+    || logLevel === 'verbose';
+}
+
 export async function runBrowserSuite(options = {}) {
   return runWithRuntimeIsolationForSuite(async () => {
     const suiteTimestamp = resolveReportTimestamp(options.timestamp, 'runBrowserSuite timestamp');
     const suiteContext = resolveSuiteContext(options);
     const suite = normalizeSuite(options.suite, suiteContext);
+    const captureDebugSnapshot = shouldCaptureDebugSnapshot(suite, getRuntimeConfig());
+    if (captureDebugSnapshot) {
+      clearLogHistory();
+    }
     const suiteResult = await dispatchBrowserSuite(suite, options);
     if (!suiteResult) {
       throw createUnsupportedSuiteError(suite, suiteContext);
     }
+    const debugSnapshot = captureDebugSnapshot ? getDebugSnapshot() : null;
 
     if (suite === 'bench' && suiteResult?.metrics?.workloadType === 'training') {
       const trainingReport = suiteResult?.metrics?.trainingMetricsReport;
@@ -886,6 +904,7 @@ export async function runBrowserSuite(options = {}) {
       metrics: suiteResult.metrics ?? null,
       output: reportOutput,
       memory: suiteResult.memoryStats ?? null,
+      debugSnapshot,
       ...options.report,
     };
     if (ulArtifacts.length > 0 || distillArtifacts.length > 0 || checkpointResumeTimeline.length > 0) {
@@ -907,7 +926,7 @@ export async function runBrowserSuite(options = {}) {
       report.timestamp = suiteTimestamp;
     }
     const reportInfo = await saveReport(modelId, report, { timestamp: report.timestamp });
-    return { ...suiteResult, report, reportInfo };
+    return { ...suiteResult, debugSnapshot, report, reportInfo };
   });
 }
 

package/src/inference/kv-cache/base.js

@@ -314,10 +314,7 @@ export class KVCache {
     layer.seqLen = Math.max(layer.seqLen, startPos + numNewTokens);
     this.totalTokensSeen = Math.max(this.totalTokensSeen, startPos + numNewTokens);
 
-    // Update global sequence length if this is the last layer
-    if (layerIdx === this.numLayers - 1) {
-      this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numNewTokens);
-    }
+    this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numNewTokens);
   }
 
   
@@ -374,9 +371,7 @@ export class KVCache {
     layer.seqLen = Math.max(layer.seqLen, startPos + numTokens);
     this.totalTokensSeen = Math.max(this.totalTokensSeen, startPos + numTokens);
 
-    if (layerIdx === this.numLayers - 1) {
-      this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numTokens);
-    }
+    this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numTokens);
   }
 
   
@@ -433,9 +428,7 @@ export class KVCache {
     layer.seqLen = Math.max(layer.seqLen, startPos + numTokens);
     this.totalTokensSeen = Math.max(this.totalTokensSeen, startPos + numTokens);
 
-    if (layerIdx === this.numLayers - 1) {
-      this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numTokens);
-    }
+    this.currentSeqLen = Math.max(this.currentSeqLen, startPos + numTokens);
   }
 
   

package/src/inference/pipelines/diffusion/helpers.js

@@ -89,6 +89,9 @@ export function normalizeDiffusionMatmulLocationDtype(dtype) {
   return normalized;
 }
 
+// Artifact-derived dtype inference: determines actual storage dtype from buffer byte size.
+// This is NOT a config-bypass — it reads physical buffer dimensions (artifact-derived config),
+// which is a valid merge layer per the config merge contract.
 export function inferDiffusionMatmulDtypeFromBuffer(weight, N, K, preferred) {
   const buffer = getBuffer(weight);
   if (!buffer || !Number.isFinite(N) || !Number.isFinite(K)) return preferred;

package/src/inference/pipelines/diffusion/pipeline.js

@@ -28,6 +28,7 @@ import { runResidualAdd, runScale, recordResidualAdd, recordScale } from '../../
 import { f16ToF32 } from '../../../loader/dtype-utils.js';
 
 const SUPPORTED_DIFFUSION_BACKEND_PIPELINES = new Set(['gpu']);
+const DEFAULT_TIME_EMBED_DIM = 256;
 const SD3_TEXT_ENCODER_KEYS = ['text_encoder', 'text_encoder_2', 'text_encoder_3'];
 const SANA_TEXT_ENCODER_KEYS = ['text_encoder'];
 
@@ -492,7 +493,7 @@ export class DiffusionPipeline {
     const hiddenSize = (transformerConfig.num_attention_heads ?? 0) * (transformerConfig.attention_head_dim ?? 0);
     const patchSize = transformerConfig.patch_size ?? 2;
     const timeEmbedWeight = transformerResolver.get('time_text_embed.timestep_embedder.linear_1.weight');
-    const timeEmbedDim = timeEmbedWeight?.shape?.[1] ?? transformerConfig.time_embed_dim ?? 256;
+    const timeEmbedDim = timeEmbedWeight?.shape?.[1] ?? transformerConfig.time_embed_dim ?? DEFAULT_TIME_EMBED_DIM;
     if (!Number.isFinite(hiddenSize) || hiddenSize <= 0) {
       throw new Error('Diffusion transformer config missing num_attention_heads/attention_head_dim.');
     }

package/src/inference/pipelines/diffusion/text-encoder-gpu.js

@@ -44,7 +44,10 @@ import { initRoPEFrequencies } from '../text/init.js';
 import { processLayerGPU } from '../text/layer.js';
 
 const QUICK_GELU_ALPHA = 1.702;
+const DEFAULT_TIMESTEP_EMBED_DIM = 256;
 const SUPPORTED_CLIP_HIDDEN_ACTIVATIONS = new Set(['gelu', 'quick_gelu']);
+// Standard CLIP hidden activation per OpenAI CLIP specification.
+const DEFAULT_CLIP_HIDDEN_ACT = 'gelu';
 
 function padTokens(tokens, maxLength, padTokenId) {
   if (!Number.isFinite(maxLength) || maxLength <= 0) {
@@ -100,11 +103,15 @@ function createVectorTensor(device, data, dtype, label) {
   return createTensor(buffer, dtype, [1, length], label);
 }
 
+// Conservative fallback dtype for diffusion bias tensors when no dtype
+// metadata is available. F32 avoids precision loss in bias additions.
+const DEFAULT_BIAS_DTYPE = 'f32';
+
 function resolveBiasDtype(weight, weightsEntry, key) {
   if (weight && weight.dtype) return weight.dtype;
   const locationDtype = weightsEntry?.dtypes?.get(key);
   const mapped = normalizeDiffusionLocationDtype(locationDtype);
-  return mapped || 'f32';
+  return mapped || DEFAULT_BIAS_DTYPE;
 }
 
 function createBiasTensorWithDtype(weight, weightsEntry, key, size, label) {
@@ -145,7 +152,7 @@ function createKernelOps(recorder) {
 }
 
 function resolveClipHiddenActivation(config) {
-  const hiddenAct = config?.hidden_act ?? 'gelu';
+  const hiddenAct = config?.hidden_act ?? DEFAULT_CLIP_HIDDEN_ACT;
   if (!SUPPORTED_CLIP_HIDDEN_ACTIVATIONS.has(hiddenAct)) {
     throw new Error(
       `Unsupported CLIP hidden_act "${hiddenAct}". ` +
@@ -1099,7 +1106,7 @@ export async function buildTimestepEmbedding(timestep, weightsEntry, modelConfig
   const device = getDevice();
   if (!device) throw new Error('Timestep embedding requires a WebGPU device.');
 
-  const dim = options.dim ?? 256;
+  const dim = options.dim ?? DEFAULT_TIMESTEP_EMBED_DIM;
   const half = Math.floor(dim / 2);
   const emb = new Float32Array(dim);
   const maxPeriod = 10000;

package/src/inference/pipelines/text/attention/output-projection.d.ts

@@ -0,0 +1,12 @@
+import type { Tensor } from '../../../../gpu/tensor.js';
+
+export interface AttentionProjectionInputResult {
+  oProjInput: Tensor;
+  oProjInputTemp: Tensor | null;
+}
+
+export function prepareAttentionProjectionInput(
+  attnForProjection: Tensor,
+  matmulOutputDtype: string,
+  castToF16: (tensor: Tensor) => Promise<Tensor>
+): Promise<AttentionProjectionInputResult>;