@simulatte/doppler 0.1.7 → 0.1.9

package/src/inference/pipelines/text/init.d.ts

@@ -28,6 +28,7 @@ import type {
   SpeculativeConfigSchema,
   KernelPathSchema,
 } from '../../../config/schema/index.js';
+import type { LoaderDebugConfigSchema } from '../../../config/schema/debug.schema.js';
 import type { KernelPathSource } from '../../../config/kernel-path-loader.js';
 
 export interface PipelineStorageContext {
@@ -190,6 +191,12 @@ export interface WeightLoadResult {
   layerRouterWeights: Map<number, RouterWeights>;
 }
 
+export interface ResolvedQ4KConfig {
+  useFusedQ4K: boolean;
+  q4kLayout: 'row' | 'col' | null;
+  keepF32Weights: boolean;
+}
+
 /** Options for loadWeights */
 export interface LoadWeightsOptions {
   storageContext?: PipelineStorageContext;
@@ -200,6 +207,7 @@ export interface LoadWeightsOptions {
   resolvedKernelPath?: KernelPathSchema | null;
   kernelPathSource?: KernelPathSource;
   keepF32Weights?: boolean;
+  loaderDebug?: LoaderDebugConfigSchema | null;
 }
 
 /**
@@ -211,6 +219,13 @@ export function loadWeights(
   options?: LoadWeightsOptions
 ): Promise<WeightLoadResult>;
 
+export function resolveQ4KConfig(
+  manifest: Manifest,
+  kernelPath?: KernelPathSchema | null,
+  kernelPathSource?: KernelPathSource,
+  keepF32Weights?: boolean
+): ResolvedQ4KConfig;
+
 /**
  * Apply Gemma chat template to a prompt.
  */

package/src/inference/pipelines/text/init.js

@@ -11,7 +11,7 @@ import { getDopplerLoader } from '../../../loader/doppler-loader.js';
 import { log, setGPUDevice, trace as debugTrace } from '../../../debug/index.js';
 import { getRuntimeConfig } from '../../../config/runtime.js';
 import { PAGED_LAYOUT_SEQ_LEN_THRESHOLD } from '../../../config/schema/index.js';
-import { isKernelPathFusedQ4K } from '../../../config/kernel-path-loader.js';
+import { isKernelPathFusedQ4K, kernelPathRequiresF32MatmulWeights } from '../../../config/kernel-path-loader.js';
 import { createWeightBuffer, getWeightDtype, isWeightBuffer } from '../../../gpu/weight-buffer.js';
 import { selectRuleValue } from '../../../rules/rule-registry.js';
 import {
@@ -128,7 +128,7 @@ function createRemoteStorageContext(baseUrl, manifest) {
 }
 
 
-function resolveQ4KConfig(
+export function resolveQ4KConfig(
   manifest,
   kernelPath,
   kernelPathSource = 'none',
@@ -150,18 +150,23 @@ function resolveQ4KConfig(
     );
   }
   let useFused = kernelPath ? isKernelPathFusedQ4K(kernelPath) : hasSubgroups;
+  const kernelPathKeepsF32Weights = kernelPathRequiresF32MatmulWeights(kernelPath);
   if (q4kLayout === 'col') {
     useFused = false;
   }
+  const resolvedKeepF32Weights = keepF32Weights || kernelPathKeepsF32Weights;
 
   const pathLabel = kernelPath?.id ?? 'auto';
   const layoutLabel = q4kLayout ?? 'none';
-  debugTrace.loader(`Q4K config: fused=${useFused}, kernelPath=${pathLabel}, source=${kernelPathSource}, layout=${layoutLabel}, subgroups=${hasSubgroups}`);
+  debugTrace.loader(
+    `Q4K config: fused=${useFused}, kernelPath=${pathLabel}, source=${kernelPathSource}, ` +
+    `layout=${layoutLabel}, keepF32Weights=${resolvedKeepF32Weights}, subgroups=${hasSubgroups}`
+  );
 
   return {
     useFusedQ4K: useFused,
     q4kLayout,
-    keepF32Weights,
+    keepF32Weights: resolvedKeepF32Weights,
   };
 }
 
@@ -304,13 +309,21 @@ export async function initRoPEFrequencies(config, useGPU) {
   if (!Number.isFinite(ropeScale) || ropeScale <= 0) {
     throw new Error(`RoPE scale must be a positive number; got "${ropeScale}".`);
   }
-  const resolvedLocalScale = ropeLocalScale ?? ropeScale;
-  if (!Number.isFinite(resolvedLocalScale) || resolvedLocalScale <= 0) {
+  const resolvedLocalScale = ropeLocalScale;
+  if (resolvedLocalScale != null && (!Number.isFinite(resolvedLocalScale) || resolvedLocalScale <= 0)) {
     throw new Error(`Local RoPE scale must be a positive number; got "${resolvedLocalScale}".`);
   }
   const resolvedLocalTheta = ropeLocalTheta ?? ropeTheta;
-  const resolvedLocalScalingType = ropeLocalScalingType ?? ropeScalingType;
-  const resolvedLocalScaling = ropeLocalScaling ?? ropeScaling;
+  const resolvedLocalScalingType = (
+    ropeLocalScalingType === undefined
+      ? ropeScalingType
+      : ropeLocalScalingType
+  );
+  const resolvedLocalScaling = (
+    ropeLocalScalingType === undefined
+      ? ropeScaling
+      : ropeLocalScaling
+  );
   const resolvedRotaryDim = resolveRotaryDim(headDim, rotaryDim, partialRotaryFactor);
   const halfDim = resolvedRotaryDim / 2;
   if (mropeInterleaved === true && Array.isArray(mropeSection)) {
@@ -502,6 +515,12 @@ export function createKVCache(modelConfig, useGPU, debug = false, runtimeConfig)
     cacheLayout = 'paged';
     layoutSource = 'threshold';
   }
+  if (forceContiguousKVCache && cacheLayout === 'paged') {
+    throw new Error(
+      'Paged KV cache layout is not supported for models with full-attention layers. ' +
+      'Set runtime.inference.kvcache.layout to "contiguous" instead.'
+    );
+  }
   if (debug && cacheLayout !== runtimeKV.layout) {
     log.debug('Pipeline', `KV cache layout override: ${runtimeKV.layout} -> ${cacheLayout} (${layoutSource})`);
   }
@@ -599,7 +618,7 @@ export function createKVCache(modelConfig, useGPU, debug = false, runtimeConfig)
 
   if (debug) {
     if (forceContiguousKVCache && modelConfig.layerTypes) {
-      log.debug('Pipeline', 'Layer pattern includes full-attention layers; forcing contiguous KV cache.');
+      log.debug('Pipeline', 'Layer pattern includes full-attention layers; paged layout blocked, contiguous enforced.');
     }
     const isSliding = kvCache instanceof SlidingWindowKVCache;
     log.debug('Pipeline', `KV cache: type=${kvCache?.constructor?.name || 'unknown'}, kvDtype=${kvCache.kvDtype}, layout=${kvCache.layout}, maxSeqLen=${kvCache.maxSeqLen}, windowSize=${isSliding ? kvCache.windowSize : null}`);
@@ -635,7 +654,12 @@ export async function initTokenizer(manifest, options = {}) {
 
 
 export async function loadWeights(manifest, modelConfig, options = {}) {
-  const { onProgress, loadingConfig, baseUrl } = options;
+  const {
+    onProgress,
+    loadingConfig,
+    baseUrl,
+    loaderDebug,
+  } = options;
   const runtimeStorageContext = options.storageContext
     ?? createRemoteStorageContext(baseUrl, manifest);
   const verifyHashes = (
@@ -657,6 +681,7 @@ export async function loadWeights(manifest, modelConfig, options = {}) {
       keepF32Weights
     )
   );
+  dopplerLoader.setLoaderDebugConfig(loaderDebug ?? null);
 
   const tensorsFile = isRDRRManifest(manifest) ? manifest.tensorsFile : null;
   if (baseUrl && tensorsFile) {

package/src/inference/pipelines/text/layer.js

@@ -43,19 +43,16 @@ export function detectSandwichNorm(config) {
 }
 
 
-export function isMoELayer(layerIdx, config, layerWeights) {
+export function isMoELayer(layerIdx, config) {
   if (!config.useMoE) return false;
 
-  // Check if layer has router weights
-  if (layerWeights?.routerWeight) return true;
-
-  // Fall back to layer_types array if available
+  // Manifest-first: check layerTypes from config (derived from manifest.inference.layerPattern)
   const layerTypes = config.layerTypes;
   if (Array.isArray(layerTypes) && layerIdx < layerTypes.length) {
     return layerTypes[layerIdx] === 'moe';
   }
 
-  // Default: assume all layers are MoE if model uses MoE
+  // No layerTypes available: assume all layers are MoE
   return true;
 }
 
@@ -87,6 +84,11 @@ function assertSupportedLayerRuntime(layerIdx, config) {
   }
 }
 
+function getConvLayerState(convLayerStates, layerIdx) {
+  if (!convLayerStates) return {};
+  return convLayerStates.get(layerIdx) ?? {};
+}
+
 function isSlidingLayerType(layerType) {
   const normalized = normalizeLayerType(layerType);
   return normalized === 'sliding_attention'
@@ -103,6 +105,14 @@ function isConvLayerType(layerType) {
     || normalized === 'liv_convolution';
 }
 
+export function hasConvLayers(layerTypes) {
+  if (!Array.isArray(layerTypes)) return false;
+  for (let i = 0; i < layerTypes.length; i++) {
+    if (isConvLayerType(layerTypes[i])) return true;
+  }
+  return false;
+}
+
 function isLinearLayerType(layerType) {
   const normalized = normalizeLayerType(layerType);
   return normalized === 'linear_attention'
@@ -201,8 +211,22 @@ export async function processLayerGPU(layerIdx, inputBuffer, numTokens, isPrefil
       );
     }
     const convKernel = layerWeights?.convKernel ?? null;
+    // Apply input norm (operator_norm) before conv mixer — matches HF Lfm2 forward pass
+    let normedTensor = inputTensor;
+    const inputNormWeight = layerWeights?.inputNorm ?? null;
+    if (inputNormWeight) {
+      const normWeightBuf = getNormWeightBuffer(inputNormWeight, `L${layerIdx}.conv_input_norm`);
+      normedTensor = await doRMSNorm(inputTensor, normWeightBuf, rmsNormEps, {
+        batchSize: numTokens,
+        hiddenSize,
+        rmsNormWeightOffset: config.rmsNormWeightOffset,
+        label: `L${layerIdx}.conv_input_norm`,
+        layerIdx,
+      }, recorder);
+      if (!(inputNormWeight instanceof GPUBuffer)) releaseOrTrack(recorder, normWeightBuf);
+    }
     attnOutput = await doConv(
-      inputTensor,
+      normedTensor,
       getWeightBuffer(convInProj, `L${layerIdx}.conv_in_proj`),
       convKernel ? getWeightBuffer(convKernel, `L${layerIdx}.conv_kernel`) : null,
       getWeightBuffer(convOutProj, `L${layerIdx}.conv_out_proj`),
@@ -213,9 +237,13 @@ export async function processLayerGPU(layerIdx, inputBuffer, numTokens, isPrefil
         label: `L${layerIdx}.conv`,
         swigluLimit: config.swigluLimit,
         kernelPath: context.kernelPath ?? null,
+        convState: getConvLayerState(context.convLayerStates, layerIdx),
       },
       recorder
     );
+    if (normedTensor !== inputTensor) {
+      releaseOrTrack(recorder, normedTensor.buffer);
+    }
   } else if (isLinearLayer) {
     attnOutput = await runLinearAttentionLayer(inputTensor, layerWeights ?? null, {
       layerIdx,
@@ -276,6 +304,7 @@ export async function processLayerGPU(layerIdx, inputBuffer, numTokens, isPrefil
         : (ropeFreqsSin),
       kvCache: ((kvCache)),
       stats: context.stats,
+      debugProbes: context.debugProbes,
       linearRuntime: context.linearAttentionRuntime ?? null,
     };
 
@@ -720,6 +749,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               label: `L${layerIdx}.plan_conv`,
               swigluLimit: config.swigluLimit,
               kernelPath: context.kernelPath ?? null,
+              convState: getConvLayerState(context.convLayerStates, layerIdx),
             },
             recorder
           );
@@ -781,7 +811,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
           let outputTensor;
           const { runMoEFFNGPU, runDenseFFNGPU } = await import('./ffn/index.js');
 
-          const canAutoMoe = config.useMoE && isMoELayer(layerIdx, config, layerWeights);
+          const canAutoMoe = config.useMoE && isMoELayer(layerIdx, config);
           const useMoe = selectRuleValue(
             'inference',
             'layer',

package/src/inference/pipelines/text/linear-attention.d.ts

@@ -84,6 +84,11 @@ export declare function inferLinearNormMode(
   }
 ): LinearNormMode | null;
 
+export declare function applyLinearNormWeightOffset(
+  values: Float32Array,
+  rmsNormWeightOffset: boolean
+): Float32Array;
+
 export declare function resetLinearAttentionRuntime(
   runtime: LinearAttentionRuntime | null | undefined
 ): LinearAttentionRuntime;

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

@@ -5,6 +5,8 @@ import { log } from '../../../debug/index.js';
 import { decodeReadback } from './debug-utils/index.js';
 import { runLinearAttentionCoreGPU } from '../../../gpu/kernels/linear-attention-core.js';
 import { runProbes } from './probes.js';
+import { QK_K, Q4K_BLOCK_BYTES } from '../../../config/schema/index.js';
+import { dequantizeQ4KM } from '../../../converter/quantizer.js';
 
 const LINEAR_RUNTIME_SCHEMA_VERSION = 1;
 const QK_L2NORM_EPS = 1e-6;
@@ -34,6 +36,15 @@ function bytesFromDtype(dtype) {
   return 4;
 }
 
+export function applyLinearNormWeightOffset(values, rmsNormWeightOffset) {
+  if (!(values instanceof Float32Array)) {
+    throw new Error('applyLinearNormWeightOffset requires Float32Array input.');
+  }
+  // Qwen linear-attention output norm uses direct weights even when surrounding
+  // transformer RMSNorm sites use the Gemma-style (1 + weight) formula.
+  return values;
+}
+
 function cloneLayerRuntimeState(layerState) {
   return {
     layerIdx: layerState.layerIdx,
@@ -283,9 +294,27 @@ async function readWeightAsF32(weight, expectedElements, label) {
   if (!elementCount && isWeightBuffer(weight) && Array.isArray(weight.shape) && weight.shape.length > 0) {
     elementCount = weight.shape.reduce((total, dim) => total * Math.max(1, Math.trunc(Number(dim) || 0)), 1);
   }
+  const isQ4K = sourceDtype === 'q4k' || sourceDtype === 'q4_k_m' || sourceDtype === 'q4_k';
   if (!elementCount) {
-    const inferredBytes = sourceDtype === 'f16' || sourceDtype === 'bf16' ? 2 : 4;
-    elementCount = Math.trunc(sourceBuffer.size / inferredBytes);
+    if (isQ4K) {
+      elementCount = Math.trunc(sourceBuffer.size / Q4K_BLOCK_BYTES) * QK_K;
+    } else {
+      const inferredBytes = sourceDtype === 'f16' || sourceDtype === 'bf16' ? 2 : 4;
+      elementCount = Math.trunc(sourceBuffer.size / inferredBytes);
+    }
+  }
+
+  if (isQ4K) {
+    const numBlocks = Math.ceil(elementCount / QK_K);
+    const q4kBytes = numBlocks * Q4K_BLOCK_BYTES;
+    const raw = await readBuffer(sourceBuffer, q4kBytes);
+    const decoded = dequantizeQ4KM(new Uint8Array(raw), numBlocks, [elementCount]);
+    if (expectedElements != null && decoded.length !== expectedElements) {
+      throw new Error(
+        `Weight "${label}" Q4K decoded length ${decoded.length}, expected ${expectedElements}.`
+      );
+    }
+    return decoded;
   }
 
   if (!sourceDtype) {
@@ -454,6 +483,7 @@ async function createLayerRuntimeState(
     expectedNormElements,
     `L${layerIdx}.linear_attn.norm.weight`
   );
+  const runtimeNorm = applyLinearNormWeightOffset(norm, config.rmsNormWeightOffset === true);
 
   const aNegExp = new Float32Array(aLog.length);
   for (let i = 0; i < aLog.length; i++) {
@@ -490,7 +520,7 @@ async function createLayerRuntimeState(
     convWeight,
     dtBias,
     aNegExp,
-    normWeight: norm,
+    normWeight: runtimeNorm,
     convState,
     recurrentState,
     convWeightGPU: null,

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

@@ -304,7 +304,7 @@ export async function computeLogitsGPU(
 
   const logitsTensor = await runMatmul(normedTensor, lmHeadBuffer, numTokens, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: forceStableF32Logits ? undefined : 'lm_head',
+    role: 'lm_head',
     kernelPath: config.kernelPath ?? null,
   });
 
@@ -391,7 +391,7 @@ export async function recordLogitsGPU(
   // Record matmul (no submit)
   const logitsTensor = await recordMatmul(recorder, normedTensor, lmHeadBuffer, numTokens, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: forceStableF32Logits ? undefined : 'lm_head',
+    role: 'lm_head',
     kernelPath: config.kernelPath ?? null,
   });
 

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

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

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

@@ -253,6 +253,7 @@ export async function computeLogits(
 
   const lastPositionOnly = options?.lastPositionOnly === true && numTokens > 1;
   const matmulRows = lastPositionOnly ? 1 : numTokens;
+  const matmulPhaseOverride = lastPositionOnly ? 'prefill' : null;
   let matmulInputTensor = normedTensor;
   let matmulInputOwned = false;
   if (lastPositionOnly) {
@@ -270,7 +271,8 @@ export async function computeLogits(
   // HuggingFace models store lm_head as [vocabSize, hiddenSize], so transposeB=true
   const logitsTensor = await runMatmul(matmulInputTensor, lmHeadBuffer, matmulRows, matmulVocabSize, hiddenSize, {
     transposeB: 'auto',
-    role: (forceStableF32Logits || lastPositionOnly) ? undefined : 'lm_head',
+    role: 'lm_head',
+    phaseOverride: matmulPhaseOverride,
     kernelPath: config.kernelPath ?? null,
   });
   await runProbes('logits', logitsTensor.buffer, {

package/src/inference/pipelines/text/model-load.js

@@ -234,6 +234,9 @@ function buildManifestDecodeLoopRuntimePatch(manifest) {
 
 export function applyModelBatchingRuntimeDefaults(runtimeConfig, manifest, modelConfig) {
   void modelConfig;
+  if (manifest?.inference?.schema === 'doppler.execution/v0') {
+    return runtimeConfig;
+  }
   const batching = runtimeConfig?.inference?.batching;
   const generation = runtimeConfig?.inference?.generation;
   const runtimeBatchingAtDefaults = isRuntimeBatchingAtGlobalDefaults(batching);

package/src/inference/pipelines/text/moe-gpu.js

@@ -23,6 +23,7 @@ import {
   validateMoeShape,
   resolveMoeVendorProfile,
   resolveGptOssKernelPathProfile,
+  resolveMixtralKernelPathProfile,
 } from './moe-shape-validator.js';
 
 export async function moeFeedForwardGPU(
@@ -52,7 +53,10 @@ export async function moeFeedForwardGPU(
   if (topK == null) {
     throw new Error('MoE topK is required in config.');
   }
-  const modelType = config.modelType ?? (expertFormat === 'gpt-oss' ? 'gpt-oss' : 'mixtral');
+  if (config.modelType == null) {
+    throw new Error('MoE config.modelType is required; got null/undefined.');
+  }
+  const modelType = config.modelType;
   validateMoeShape(
     { hiddenSize, intermediateSize, moeTopK: topK, numExperts, expertFormat },
     { modelType }
@@ -130,7 +134,13 @@ export async function moeFeedForwardGPU(
     trace.buffers(`MoE L${layerIdx} router_logits`, { min, max, nanCount, dtype: logitsDtype });
   }
 
+  // Profile resolution: routerTopK/dequantExpert are resolved for tracing and
+  // forward validation. Actual kernel dispatch uses the generic softmax.rules.json
+  // topkVariant rules (keyed by modelType) and format-specific dequant paths.
+  // GPT-OSS: dequantTileShape actively steers MXFP4 dequant; routerTopK is trace-only.
+  // Mixtral: expert weights are pre-loaded (no runtime dequant); both fields are trace-only.
   let gptOssKernelPathProfile = null;
+  let mixtralKernelPathProfile = null;
   if (modelType === 'gpt-oss') {
     gptOssKernelPathProfile = await resolveGptOssKernelPathProfile({
       hasF16: caps.hasF16,
@@ -141,6 +151,14 @@ export async function moeFeedForwardGPU(
       groupSize: 32,
       tileShape: vendorProfile.dequantTileShape,
     });
+  } else if (modelType === 'mixtral') {
+    mixtralKernelPathProfile = await resolveMixtralKernelPathProfile({
+      hasF16: caps.hasF16,
+      hasSubgroups: caps.hasSubgroups,
+      routerDtype: logitsDtype,
+      weightsDtype: activationDtype,
+      outputDtype: activationDtype,
+    });
   }
 
   stepStart = perfMark();
@@ -159,7 +177,7 @@ export async function moeFeedForwardGPU(
   perfLog(`MoE L${layerIdx} topk`, stepStart, {
     topK,
     modelType,
-    routerTopKKernel: gptOssKernelPathProfile?.routerTopK ?? null,
+    routerTopKKernel: gptOssKernelPathProfile?.routerTopK ?? mixtralKernelPathProfile?.routerTopK ?? null,
   });
 
   if (isTraceEnabled('buffers')) {
@@ -211,7 +229,7 @@ export async function moeFeedForwardGPU(
   const bytesPerElement = selectRuleValue('shared', 'dtype', 'bytesFromDtype', { dtype: activationDtype });
   const bytesPerToken = hiddenSize * bytesPerElement;
   let maxTokensPerExpert = resolveMaxTokensPerExpert(numTokens, numExperts, topK, hiddenSize, activationDtype);
-  if (modelType === 'gpt-oss') {
+  if (vendorProfile.maxTokensPerExpertScale !== 1.0) {
     maxTokensPerExpert = Math.max(
       1,
       Math.round(maxTokensPerExpert * vendorProfile.maxTokensPerExpertScale)

package/src/inference/pipelines/text/moe-shape-validator.d.ts

@@ -29,3 +29,12 @@ export interface GptOssKernelPathProfile {
 export declare function resolveGptOssKernelPathProfile(
   context: Record<string, unknown>
 ): Promise<GptOssKernelPathProfile>;
+
+export interface MixtralKernelPathProfile {
+  routerTopK: string;
+  dequantExpert: string;
+}
+
+export declare function resolveMixtralKernelPathProfile(
+  context: Record<string, unknown>
+): Promise<MixtralKernelPathProfile>;

package/src/inference/pipelines/text/moe-shape-validator.js

@@ -7,17 +7,15 @@ function asVendorString(caps) {
 }
 
 export function resolveMoeVendorProfile(modelType) {
-  if (modelType !== 'gpt-oss') {
-    return {
-      preferVec4Dequant: false,
-      dequantTileShape: 'scalar',
-      routerWorkgroupSize: 128,
-      maxTokensPerExpertScale: 1.0,
-    };
-  }
   const caps = getKernelCapabilities();
   const vendor = asVendorString(caps);
-  return selectRuleValue('kernels', 'moeGptoss', 'vendorQuirkProfile', { vendor });
+  if (modelType === 'gpt-oss') {
+    return selectRuleValue('kernels', 'moeGptoss', 'vendorQuirkProfile', { vendor });
+  }
+  if (modelType === 'mixtral') {
+    return selectRuleValue('kernels', 'moeMixtral', 'vendorQuirkProfile', { vendor });
+  }
+  throw new Error(`[MoE] Unknown modelType "${modelType}" for vendor profile resolution.`);
 }
 
 function resolveGptOssRuleContext(context) {
@@ -41,6 +39,25 @@ export async function resolveGptOssKernelPathProfile(context) {
   };
 }
 
+function resolveMixtralRuleContext(context) {
+  return {
+    modelType: 'mixtral',
+    hasF16: context?.hasF16,
+    hasSubgroups: context?.hasSubgroups,
+    routerDtype: context?.routerDtype ?? 'f32',
+    weightsDtype: context?.weightsDtype,
+    outputDtype: context?.outputDtype ?? context?.weightsDtype,
+  };
+}
+
+export async function resolveMixtralKernelPathProfile(context) {
+  const ruleContext = resolveMixtralRuleContext(context);
+  return {
+    routerTopK: selectRuleValue('kernels', 'moeMixtral', 'routerTopKVariant', ruleContext),
+    dequantExpert: selectRuleValue('kernels', 'moeMixtral', 'dequantVariant', ruleContext),
+  };
+}
+
 export function validateMoeShape(config, options = {}) {
   const {
     hiddenSize,
@@ -66,8 +83,11 @@ export function validateMoeShape(config, options = {}) {
 
   if (modelType === 'gpt-oss') {
     const policy = selectRuleValue('kernels', 'moeGptoss', 'shapePolicy', { modelType });
-    const hiddenDivisor = policy.hiddenSizeDivisor ?? 32;
-    const intermediateDivisor = policy.intermediateSizeDivisor ?? 32;
+    if (policy.hiddenSizeDivisor == null || policy.intermediateSizeDivisor == null) {
+      throw new Error('[MoE] GPT-OSS shapePolicy is missing hiddenSizeDivisor or intermediateSizeDivisor.');
+    }
+    const hiddenDivisor = policy.hiddenSizeDivisor;
+    const intermediateDivisor = policy.intermediateSizeDivisor;
     if (hiddenSize % hiddenDivisor !== 0 || intermediateSize % intermediateDivisor !== 0) {
       throw new Error(
         `[MoE] GPT-OSS shape policy violation: hiddenSize (${hiddenSize}) % ${hiddenDivisor} = ${hiddenSize % hiddenDivisor}, ` +