@simulatte/doppler 0.1.4 → 0.1.6

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

@@ -182,10 +182,18 @@ export async function recordLayerAttentionGPU(
   // 3. RoPE (modifies tensor in-place)
   if (!disableRoPE && state.ropeFreqsCos && state.ropeFreqsSin) {
     await recordRoPE(recorder, qTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads, headDim, startPos: currentSeqLen,
+      numHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
     await recordRoPE(recorder, kTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads: numKVHeads, headDim, startPos: currentSeqLen,
+      numHeads: numKVHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
   }
 
@@ -502,6 +510,7 @@ export async function recordLayerAttentionGPU(
       size: numTokens * numHeads * headDim,
       gate: qGateTensor,
       gateActivation: 'sigmoid',
+      inputActivation: 'identity',
       swigluLimit: null,
     });
     recorder.trackTemporaryBuffer(attnOutput.buffer);

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

@@ -299,10 +299,18 @@ export async function runLayerAttentionGPU(
 
   if (!disableRoPE && state.ropeFreqsCos && state.ropeFreqsSin) {
     await runRoPE(qTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads, headDim, startPos: currentSeqLen,
+      numHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
     await runRoPE(kTensor, state.ropeFreqsCos, state.ropeFreqsSin, numTokens, {
-      numHeads: numKVHeads, headDim, startPos: currentSeqLen,
+      numHeads: numKVHeads,
+      headDim,
+      rotaryDim: config.ropeRotaryDim,
+      interleaved: config.ropeInterleaved,
+      startPos: currentSeqLen,
     });
 
     // Trace RoPE outputs
@@ -690,6 +698,7 @@ export async function runLayerAttentionGPU(
       size: numTokens * numHeads * headDim,
       gate: qGateTensor,
       gateActivation: 'sigmoid',
+      inputActivation: 'identity',
       swigluLimit: null,
     });
     releaseBuffer(attnOutput.buffer);

package/src/inference/pipelines/text/chat-format.js

@@ -224,6 +224,29 @@ function formatChatML(messages) {
   return parts.join('');
 }
 
+function formatQwen(messages) {
+  // Qwen 3.5 chat format is ChatML-like, but the generation prelude includes
+  // an explicit empty thinking block before assistant output.
+  const parts = [];
+  for (const [index, message] of messages.entries()) {
+    const role = normalizeChatRole(message?.role);
+    assertSupportedChatRole(role, 'Qwen', index);
+    if (role === 'system' && index !== 0) {
+      throw new Error('Qwen template requires any system message to appear first.');
+    }
+    const content = normalizeChatMessageContent(message?.content);
+    if (role === 'system') {
+      parts.push(`<|im_start|>system\n${content}<|im_end|>\n`);
+    } else if (role === 'user') {
+      parts.push(`<|im_start|>user\n${content}<|im_end|>\n`);
+    } else if (role === 'assistant') {
+      parts.push(`<|im_start|>assistant\n${content}<|im_end|>\n`);
+    }
+  }
+  parts.push('<|im_start|>assistant\n<think>\n\n</think>\n\n');
+  return parts.join('');
+}
+
 function formatTranslateGemmaUserPrompt(content) {
   if (!Array.isArray(content) || content.length !== 1) {
     throw new Error(
@@ -345,7 +368,7 @@ const CHAT_FORMATTERS = {
   'llama3': formatHeaderBased,
   'gpt-oss': formatChannelBased,
   'chatml': formatChatML,
-  'qwen': formatChatML,
+  'qwen': formatQwen,
   'translategemma': formatTranslateGemma,
 };
 
@@ -363,4 +386,5 @@ export function formatChatMessages(messages, templateType) {
 export const formatGemmaChat = formatTurnBased;
 export const formatLlama3Chat = formatHeaderBased;
 export const formatGptOssChat = formatChannelBased;
+export const formatQwenChat = formatQwen;
 export const formatTranslateGemmaChat = formatTranslateGemma;

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

@@ -148,6 +148,10 @@ export interface ParsedModelConfig {
   slidingWindow: number | null;
   ropeTheta: number;
   ropeLocalTheta: number | null;
+  ropeRotaryDim: number;
+  ropeInterleaved: boolean;
+  mropeSection: number[] | null;
+  partialRotaryFactor: number | null;
   ropeScale: number;
   ropeLocalScale: number;
   ropeScalingType: string | null;
@@ -210,6 +214,11 @@ export interface ManifestWithInference {
  */
 export function hasManifestInference(manifest: Manifest): manifest is Manifest & { inference: ManifestInferenceSchema };
 
+export function validateRequiredInferenceFields(
+  inf: ManifestInferenceSchema,
+  modelId: string
+): void;
+
 /**
  * Convert MergedConfig to ParsedModelConfig.
  */

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

@@ -21,6 +21,28 @@ function assertSupportedRuntimeModelType(manifest) {
   );
 }
 
+function resolveRotaryDim(headDim, partialRotaryFactor, modelId) {
+  if (partialRotaryFactor == null) {
+    return headDim;
+  }
+  if (typeof partialRotaryFactor !== 'number' || Number.isNaN(partialRotaryFactor)) {
+    throw new Error(`Manifest "${modelId}" has invalid rope.partialRotaryFactor.`);
+  }
+  if (partialRotaryFactor <= 0 || partialRotaryFactor > 1) {
+    throw new Error(
+      `Manifest "${modelId}" requires 0 < rope.partialRotaryFactor <= 1; got ${partialRotaryFactor}.`
+    );
+  }
+  const rotaryDim = Math.trunc(headDim * partialRotaryFactor);
+  if (rotaryDim <= 0 || (rotaryDim % 2) !== 0) {
+    throw new Error(
+      `Manifest "${modelId}" resolves rope rotary dim ${rotaryDim} from headDim=${headDim} ` +
+      `and partialRotaryFactor=${partialRotaryFactor}, but rotary dim must be a positive even integer.`
+    );
+  }
+  return rotaryDim;
+}
+
 export function getStopTokenIds(manifest) {
   const eosTokenId = manifest?.eos_token_id;
   if (Array.isArray(eosTokenId)) return eosTokenId;
@@ -129,8 +151,15 @@ export function hasManifestInference(manifest) {
 }
 
 
-function validateRequiredInferenceFields(inf, modelId) {
-  
+export function validateRequiredInferenceFields(inf, modelId) {
+  inf = inf ?? {};
+  inf.attention = inf.attention ?? {};
+  inf.normalization = inf.normalization ?? {};
+  inf.ffn = inf.ffn ?? {};
+  inf.rope = inf.rope ?? {};
+  inf.output = inf.output ?? {};
+  inf.layerPattern = inf.layerPattern ?? {};
+  inf.chatTemplate = inf.chatTemplate ?? {};
   const errors = [];
 
   // Attention fields - non-nullable required
@@ -201,6 +230,20 @@ function validateRequiredInferenceFields(inf, modelId) {
   if (inf.rope.ropeLocalTheta === undefined) {
     errors.push('rope.ropeLocalTheta must be explicitly set (null for no local theta, or number)');
   }
+  if (inf.rope.mropeInterleaved == null) {
+    errors.push('rope.mropeInterleaved is required');
+  }
+  if (inf.rope.mropeSection === undefined) {
+    errors.push('rope.mropeSection must be explicitly set (null when unused, or an array of positive integers)');
+  }
+  if (inf.rope.partialRotaryFactor === undefined) {
+    errors.push('rope.partialRotaryFactor must be explicitly set (null when unused, or a number in (0, 1])');
+  } else {
+    const factor = inf.rope.partialRotaryFactor;
+    if (factor !== null && (typeof factor !== 'number' || Number.isNaN(factor) || factor <= 0 || factor > 1)) {
+      errors.push('rope.partialRotaryFactor must be a number in (0, 1] or null');
+    }
+  }
 
   // Output fields - non-nullable required
   if (inf.output.tieWordEmbeddings == null) {
@@ -458,6 +501,26 @@ export function toParsedConfigFromMerged(merged, manifest) {
   const ropeScalingType = inf.rope.ropeScalingType;
   const ropeLocalScale = inf.rope.ropeLocalScalingFactor ?? ropeScale;
   const ropeLocalScalingType = inf.rope.ropeLocalScalingType ?? ropeScalingType;
+  const partialRotaryFactor = inf.rope.partialRotaryFactor;
+  const ropeInterleaved = inf.rope.mropeInterleaved === true;
+  const mropeSection = Array.isArray(inf.rope.mropeSection)
+    ? inf.rope.mropeSection.map((entry) => Math.trunc(Number(entry)))
+    : null;
+  const ropeRotaryDim = resolveRotaryDim(arch.headDim, partialRotaryFactor, merged.modelId);
+  if (mropeSection && mropeSection.some((entry) => !Number.isFinite(entry) || entry <= 0)) {
+    throw new Error(
+      `Manifest "${merged.modelId}" has invalid rope.mropeSection; expected positive integers.`
+    );
+  }
+  if (ropeInterleaved && mropeSection) {
+    const doubledMropeDim = mropeSection.reduce((sum, entry) => sum + entry, 0) * 2;
+    if (doubledMropeDim !== ropeRotaryDim) {
+      throw new Error(
+        `Manifest "${merged.modelId}" declares rope.mropeSection=${JSON.stringify(mropeSection)}, ` +
+        `which expands to rotary dim ${doubledMropeDim}, but the resolved rotary dim is ${ropeRotaryDim}.`
+      );
+    }
+  }
 
   // Build ropeScaling object from manifest values if scaling is enabled
   // Include YARN params when present
@@ -532,6 +595,10 @@ export function toParsedConfigFromMerged(merged, manifest) {
     slidingWindow: inf.attention.slidingWindow,
     ropeTheta: inf.rope.ropeTheta,
     ropeLocalTheta: inf.rope.ropeLocalTheta,
+    ropeRotaryDim,
+    ropeInterleaved,
+    mropeSection,
+    partialRotaryFactor,
     ropeScale,
     ropeLocalScale,
     ropeScalingType,

package/src/inference/pipelines/text/execution-plan.js

@@ -42,56 +42,48 @@ function resolveFallbackActivationDtype(primaryActivationDtype) {
 function resolveFallbackKernelPath(primaryKernelPath) {
   const primaryKernelPathId = primaryKernelPath?.id ?? null;
   if (!primaryKernelPathId) {
-    return {
-      kernelPath: null,
-      kernelPathId: null,
-      kernelPathSource: 'none',
-    };
+    throw new Error(
+      '[ExecutionPlan] F16 finiteness fallback requires a primary kernel path with a stable id. ' +
+      'Add a registered kernelPath id and a finiteness fallback rule.'
+    );
   }
 
-  const primaryKernelPathIsObject = typeof primaryKernelPath === 'object' && primaryKernelPath !== null;
+  const explicitFallbackKernelPathId = typeof primaryKernelPath?.finitenessFallbackKernelPathId === 'string'
+    && primaryKernelPath.finitenessFallbackKernelPathId.length > 0
+    ? primaryKernelPath.finitenessFallbackKernelPathId
+    : null;
 
-  const fallbackKernelPathId = selectRuleValue(
+  const fallbackKernelPathId = explicitFallbackKernelPathId ?? selectRuleValue(
     'inference',
     'kernelPath',
     'finitenessFallback',
     { kernelPathId: primaryKernelPathId }
   );
 
-  const resolvedKernelPathId = typeof fallbackKernelPathId === 'string' && fallbackKernelPathId.length > 0
-    ? fallbackKernelPathId
-    : primaryKernelPathId;
-  const kernelPathSource = resolvedKernelPathId === primaryKernelPathId ? 'self' : 'rule';
+  if (typeof fallbackKernelPathId !== 'string' || fallbackKernelPathId.length === 0) {
+    throw new Error(
+      `[ExecutionPlan] Missing finiteness fallback kernel path mapping for "${primaryKernelPathId}". ` +
+      'Add an explicit rule in src/rules/inference/kernel-path.rules.json.'
+    );
+  }
 
-  if (kernelPathSource === 'self') {
-    log.warn(
-      'Pipeline',
-      `[ExecutionPlan] No finiteness fallback kernel path mapping for "${primaryKernelPathId}"; using primary kernel path.`
+  if (fallbackKernelPathId === primaryKernelPathId) {
+    throw new Error(
+      `[ExecutionPlan] Invalid finiteness fallback mapping for "${primaryKernelPathId}": ` +
+      `fallback kernel path resolves to itself. Add an explicit widening path.`
     );
   }
 
   try {
-    const kernelPath = resolveKernelPath(resolvedKernelPathId);
+    const kernelPath = resolveKernelPath(fallbackKernelPathId);
     return {
       kernelPath,
-      kernelPathId: resolvedKernelPathId,
-      kernelPathSource,
+      kernelPathId: fallbackKernelPathId,
+      kernelPathSource: 'rule',
     };
   } catch (error) {
-    if (primaryKernelPathIsObject) {
-      log.warn(
-        'Pipeline',
-        `[ExecutionPlan] Failed to resolve finiteness fallback kernel path "${resolvedKernelPathId}" ` +
-        `for "${primaryKernelPathId}", using inline kernel path as fallback. ${error?.message || error}`
-      );
-      return {
-        kernelPath: primaryKernelPath,
-        kernelPathId: primaryKernelPathId,
-        kernelPathSource,
-      };
-    }
     throw new Error(
-      `[ExecutionPlan] Failed to resolve finiteness fallback kernel path "${resolvedKernelPathId}" ` +
+      `[ExecutionPlan] Failed to resolve finiteness fallback kernel path "${fallbackKernelPathId}" ` +
       `(from "${primaryKernelPathId}"): ${error?.message || error}`
     );
   }

package/src/inference/pipelines/text/execution-v0.js

@@ -1,4 +1,13 @@
 import { mergeRuntimeValues } from '../../../config/runtime-merge.js';
+import {
+  buildExecutionV0KernelProfileKey,
+  indexExecutionV0KernelProfiles,
+  normalizeExecutionV0Dtype,
+  resolveExecutionV0KernelProfile,
+  resolveExecutionV0KVIO,
+  resolveExecutionV0Precision,
+} from '../../../config/execution-v0-contract-check.js';
+import { selectRuleValue } from '../../../rules/rule-registry.js';
 import {
   EXECUTION_V0_SCHEMA_ID,
   DEFAULT_EXECUTION_V0_POLICIES,
@@ -59,13 +68,9 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-function normalizeDtype(value, label) {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized !== 'f16' && normalized !== 'f32') {
-    throw new Error(`[ExecutionV0] ${label} must be "f16" or "f32"; got "${value}"`);
-  }
-  return normalized;
-}
+const normalizeDtype = normalizeExecutionV0Dtype;
+const resolvePrecision = resolveExecutionV0Precision;
+const resolveKVIO = resolveExecutionV0KVIO;
 
 function normalizePhase(value, label) {
   const normalized = String(value ?? '').trim().toLowerCase();
@@ -117,10 +122,7 @@ function stepHasLayer(step, layerIdx) {
   return step.layers.includes(layerIdx);
 }
 
-function buildKernelProfileKey(kernelRef) {
-  if (!kernelRef) return null;
-  return `${kernelRef.id}|${kernelRef.version}|${kernelRef.digest}`;
-}
+const buildKernelProfileKey = buildExecutionV0KernelProfileKey;
 
 function normalizeSlot(value, label) {
   if (typeof value !== 'string' || value.trim().length === 0) {
@@ -212,90 +214,10 @@ function hasDefinedPath(root, pathSegments) {
   return current !== undefined;
 }
 
-function indexKernelProfiles(sessionDefaults) {
-  const byKey = new Map();
-  const profiles = sessionDefaults?.compute?.kernelProfiles ?? [];
-  for (const profile of profiles) {
-    assertKernelRef(profile.kernelRef, 'sessionDefaults.compute.kernelProfiles[].kernelRef');
-    byKey.set(buildKernelProfileKey(profile.kernelRef), profile);
-  }
-  return byKey;
-}
+const indexKernelProfiles = indexExecutionV0KernelProfiles;
 
 function resolveProfile(profileIndex, step) {
-  const key = buildKernelProfileKey(step.kernelRef);
-  if (!key) return null;
-  return profileIndex.get(key) ?? null;
-}
-
-function resolvePrecision(step, profile, sessionDefaults) {
-  const defaults = sessionDefaults.compute.defaults;
-  const precision = {
-    inputDtype: step.precision?.inputDtype
-      ?? profile?.precision?.inputDtype
-      ?? null,
-    mathDtype: step.precision?.mathDtype
-      ?? profile?.precision?.mathDtype
-      ?? defaults.mathDtype,
-    accumDtype: step.precision?.accumDtype
-      ?? profile?.precision?.accumDtype
-      ?? defaults.accumDtype,
-    outputDtype: step.precision?.outputDtype
-      ?? profile?.precision?.outputDtype
-      ?? defaults.outputDtype,
-  };
-  const sources = {
-    inputDtype: step.precision?.inputDtype != null
-      ? 'manifest'
-      : profile?.precision?.inputDtype != null
-        ? 'kernelProfile'
-        : 'derived',
-    mathDtype: step.precision?.mathDtype != null
-      ? 'manifest'
-      : profile?.precision?.mathDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-    accumDtype: step.precision?.accumDtype != null
-      ? 'manifest'
-      : profile?.precision?.accumDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-    outputDtype: step.precision?.outputDtype != null
-      ? 'manifest'
-      : profile?.precision?.outputDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-  };
-  return { precision, sources };
-}
-
-function resolveKVIO(step, profile, sessionDefaults) {
-  if (step.kvIO) {
-    return {
-      value: {
-        readDtype: normalizeDtype(step.kvIO.readDtype, `${step.id}.kvIO.readDtype`),
-        writeDtype: normalizeDtype(step.kvIO.writeDtype, `${step.id}.kvIO.writeDtype`),
-      },
-      source: 'manifest',
-    };
-  }
-  if (profile?.kvIO) {
-    return {
-      value: {
-        readDtype: normalizeDtype(profile.kvIO.readDtype, `${step.id}.profile.kvIO.readDtype`),
-        writeDtype: normalizeDtype(profile.kvIO.writeDtype, `${step.id}.profile.kvIO.writeDtype`),
-      },
-      source: 'kernelProfile',
-    };
-  }
-  const kvDtype = normalizeDtype(
-    sessionDefaults?.kvcache?.kvDtype ?? sessionDefaults.compute.defaults.activationDtype,
-    `${step.id}.sessionDefaults.kvcache.kvDtype`
-  );
-  return {
-    value: { readDtype: kvDtype, writeDtype: kvDtype },
-    source: 'sessionDefault',
-  };
+  return resolveExecutionV0KernelProfile(profileIndex, step);
 }
 
 function validateStepShape(step, index) {
@@ -935,7 +857,7 @@ function assertInlineKernelPathSessionCompatibility(path, sessionDefaults) {
   }
 }
 
-function buildInlineKernelPath(steps, sessionDefaults, modelId, numLayers) {
+function buildInlineKernelPath(steps, sessionDefaults, modelId, numLayers, finitenessFallbackKernelPathId = null) {
   const activationDtype = normalizeDtype(
     sessionDefaults?.compute?.defaults?.activationDtype ?? 'f16',
     'sessionDefaults.compute.defaults.activationDtype'
@@ -956,6 +878,9 @@ function buildInlineKernelPath(steps, sessionDefaults, modelId, numLayers) {
     description: 'Generated from manifest.inference.execution.steps',
     activationDtype,
     kvDtype,
+    ...(typeof finitenessFallbackKernelPathId === 'string' && finitenessFallbackKernelPathId.length > 0
+      ? { finitenessFallbackKernelPathId }
+      : {}),
     decode: {
       steps: decodeSteps.length > 0 ? decodeSteps : prefillSteps,
     },
@@ -1186,7 +1111,26 @@ export function compileExecutionV0(options = {}) {
     ...resolvedDecodeSteps.filter((step) => step.phase === 'decode'),
   ];
 
-  const kernelPath = buildInlineKernelPath(patchedSteps, resolvedSession, modelId, numLayers);
+  const defaultKernelPathId = typeof manifestInference.defaultKernelPath === 'string'
+    && manifestInference.defaultKernelPath.trim().length > 0
+    ? manifestInference.defaultKernelPath.trim()
+    : null;
+  const finitenessFallbackKernelPathId = defaultKernelPathId
+    ? selectRuleValue(
+      'inference',
+      'kernelPath',
+      'finitenessFallback',
+      { kernelPathId: defaultKernelPathId }
+    )
+    : null;
+
+  const kernelPath = buildInlineKernelPath(
+    patchedSteps,
+    resolvedSession,
+    modelId,
+    numLayers,
+    finitenessFallbackKernelPathId
+  );
   const layerPipeline = buildLayerPipelineFromExecution(resolvedSteps);
   const sessionPatch = buildSessionRuntimePatch(resolvedSession);
   const modelOverrides = buildModelRuntimeOverrides(manifestInference);
@@ -1241,6 +1185,10 @@ export function applyExecutionV0RuntimeConfig(options = {}) {
   }
 
   const runtimeInferencePatch = { ...executionV0State.runtimeInferencePatch };
+  if (runtimeInference.kernelPath !== undefined) {
+    delete runtimeInferencePatch.kernelPath;
+    delete runtimeInferencePatch.kernelPathSource;
+  }
   if (runtimeInferencePatch.modelOverrides) {
     runtimeInferencePatch.modelOverrides = mergeRuntimeValues(
       runtimeInferencePatch.modelOverrides,

package/src/inference/pipelines/text/ffn/standard.js

@@ -42,6 +42,7 @@ export async function processFFNStandard(
     hiddenSize,
     probes: context.debugProbes,
     recorder,
+    dtype: normedTensor.dtype,
   });
 
   // 2. FFN
@@ -58,6 +59,7 @@ export async function processFFNStandard(
     hiddenSize,
     probes: context.debugProbes,
     recorder,
+    dtype: ffnOutput.dtype,
   });
 
   // 3. Residual add
@@ -72,6 +74,7 @@ export async function processFFNStandard(
     hiddenSize,
     probes: context.debugProbes,
     recorder,
+    dtype: output.dtype,
   });
 
   if (normedTensor !== postAttn) {

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

@@ -71,9 +71,13 @@ export interface PipelineContexts {
  */
 export interface RoPEConfig {
   headDim: number;
+  rotaryDim?: number;
   maxSeqLen: number;
   ropeTheta: number;
   ropeLocalTheta?: number | null;
+  mropeInterleaved?: boolean;
+  mropeSection?: number[] | null;
+  partialRotaryFactor?: number | null;
   ropeScale: number;
   ropeLocalScale?: number;
   ropeScalingType?: string | null;

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

@@ -206,13 +206,45 @@ function isSameRoPEScalingConfig(
       === (rightScaling?.original_max_position_embeddings ?? null);
 }
 
+function resolveRotaryDim(headDim, rotaryDim, partialRotaryFactor) {
+  if (rotaryDim != null) {
+    if (!Number.isFinite(rotaryDim) || rotaryDim <= 0 || (rotaryDim % 2) !== 0) {
+      throw new Error(`RoPE rotary dim must be a positive even integer; got "${rotaryDim}".`);
+    }
+    if (rotaryDim > headDim) {
+      throw new Error(`RoPE rotary dim ${rotaryDim} cannot exceed headDim ${headDim}.`);
+    }
+    return rotaryDim;
+  }
+  if (partialRotaryFactor == null) {
+    return headDim;
+  }
+  if (!Number.isFinite(partialRotaryFactor) || partialRotaryFactor <= 0 || partialRotaryFactor > 1) {
+    throw new Error(
+      `RoPE partialRotaryFactor must be a number in (0, 1]; got "${partialRotaryFactor}".`
+    );
+  }
+  const resolved = Math.trunc(headDim * partialRotaryFactor);
+  if (resolved <= 0 || (resolved % 2) !== 0) {
+    throw new Error(
+      `RoPE partialRotaryFactor=${partialRotaryFactor} with headDim=${headDim} resolves ` +
+      `to rotaryDim=${resolved}, but rotaryDim must be a positive even integer.`
+    );
+  }
+  return resolved;
+}
+
 
 export async function initRoPEFrequencies(config, useGPU) {
   const {
     headDim,
+    rotaryDim,
     maxSeqLen,
     ropeTheta,
     ropeLocalTheta,
+    mropeInterleaved,
+    mropeSection,
+    partialRotaryFactor,
     ropeScale,
     ropeLocalScale,
     ropeScalingType,
@@ -230,14 +262,23 @@ export async function initRoPEFrequencies(config, useGPU) {
   const resolvedLocalTheta = ropeLocalTheta ?? ropeTheta;
   const resolvedLocalScalingType = ropeLocalScalingType ?? ropeScalingType;
   const resolvedLocalScaling = ropeLocalScaling ?? ropeScaling;
+  const resolvedRotaryDim = resolveRotaryDim(headDim, rotaryDim, partialRotaryFactor);
+  const halfDim = resolvedRotaryDim / 2;
+  if (mropeInterleaved === true && Array.isArray(mropeSection)) {
+    const expandedDim = mropeSection.reduce((sum, entry) => sum + entry, 0) * 2;
+    if (expandedDim !== resolvedRotaryDim) {
+      throw new Error(
+        `RoPE mropeSection expands to ${expandedDim} dims, but rotaryDim is ${resolvedRotaryDim}.`
+      );
+    }
+  }
 
-  const halfDim = headDim / 2;
   const isYarn = ropeScalingType === 'yarn';
   const isLocalYarn = resolvedLocalScalingType === 'yarn';
 
   // Compute global (full_attention) frequencies
   const globalFreqs = computeRoPEFreqsForTheta(
-    ropeTheta, headDim, maxSeqLen, ropeScale, ropeScalingType, ropeScaling
+    ropeTheta, resolvedRotaryDim, maxSeqLen, ropeScale, ropeScalingType, ropeScaling
   );
 
   // Compute local (sliding_attention) frequencies if different from global.
@@ -256,7 +297,7 @@ export async function initRoPEFrequencies(config, useGPU) {
   if (hasDistinctLocalTheta || hasDistinctLocalScaling) {
     localFreqs = computeRoPEFreqsForTheta(
       resolvedLocalTheta,
-      headDim,
+      resolvedRotaryDim,
       maxSeqLen,
       resolvedLocalScale,
       resolvedLocalScalingType,
@@ -303,9 +344,10 @@ export async function initRoPEFrequencies(config, useGPU) {
 
     log.debug(
       'Pipeline',
-      `RoPE frequencies initialized (GPU): ${maxSeqLen} positions, dim=${halfDim}, headDim=${headDim}, ` +
+      `RoPE frequencies initialized (GPU): ${maxSeqLen} positions, dim=${halfDim}, headDim=${headDim}, rotaryDim=${resolvedRotaryDim}, ` +
       `theta=${ropeTheta}${hasDistinctLocalTheta ? `, localTheta=${resolvedLocalTheta}` : ''}, ` +
-      `scaling=${ropeScalingType ?? 'none'}:${ropeScale}${hasDistinctLocalScaling ? `, localScaling=${resolvedLocalScalingType ?? 'none'}:${resolvedLocalScale}` : ''}`
+      `scaling=${ropeScalingType ?? 'none'}:${ropeScale}${hasDistinctLocalScaling ? `, localScaling=${resolvedLocalScalingType ?? 'none'}:${resolvedLocalScale}` : ''}, ` +
+      `interleaved=${mropeInterleaved === true}`
     );
 
     return {
@@ -318,9 +360,10 @@ export async function initRoPEFrequencies(config, useGPU) {
 
   log.debug(
     'Pipeline',
-    `RoPE frequencies initialized (CPU): ${maxSeqLen} positions, dim=${halfDim}, headDim=${headDim}, ` +
+    `RoPE frequencies initialized (CPU): ${maxSeqLen} positions, dim=${halfDim}, headDim=${headDim}, rotaryDim=${resolvedRotaryDim}, ` +
     `theta=${ropeTheta}${hasDistinctLocalTheta ? `, localTheta=${resolvedLocalTheta}` : ''}, ` +
-    `scaling=${ropeScalingType ?? 'none'}:${ropeScale}${hasDistinctLocalScaling ? `, localScaling=${resolvedLocalScalingType ?? 'none'}:${resolvedLocalScale}` : ''}`
+    `scaling=${ropeScalingType ?? 'none'}:${ropeScale}${hasDistinctLocalScaling ? `, localScaling=${resolvedLocalScalingType ?? 'none'}:${resolvedLocalScale}` : ''}, ` +
+    `interleaved=${mropeInterleaved === true}`
   );
 
   return {
@@ -688,6 +731,10 @@ function applyChatMLTemplate(prompt) {
   return `<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n`;
 }
 
+function applyQwenTemplate(prompt) {
+  return `<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n`;
+}
+
 function applyTranslateGemmaTemplate() {
   throw new Error(
     'TranslateGemma template requires structured messages. ' +
@@ -702,7 +749,7 @@ const PROMPT_TEMPLATES = {
   'llama3': applyHeaderBasedTemplate,
   'gpt-oss': applyChannelBasedTemplate,
   'chatml': applyChatMLTemplate,
-  'qwen': applyChatMLTemplate,  // Qwen uses ChatML format
+  'qwen': applyQwenTemplate,
   'translategemma': applyTranslateGemmaTemplate,
 };
 
@@ -721,7 +768,7 @@ export function applyChatTemplate(prompt, templateType) {
 export const applyGemmaChatTemplate = applyTurnBasedTemplate;
 export const applyLlama3ChatTemplate = applyHeaderBasedTemplate;
 export const applyGptOssChatTemplate = applyChannelBasedTemplate;
-export const applyQwenChatTemplate = applyChatMLTemplate;
+export const applyQwenChatTemplate = applyQwenTemplate;
 
 
 export function isStopToken(token, stopTokenIds, eosTokenId) {