@simulatte/doppler 0.1.5 → 0.1.7

package/src/converter/conversion-plan.js

@@ -17,6 +17,8 @@ import { sanitizeModelId } from './core.js';
 import { classifyTensorRole } from '../formats/rdrr/index.js';
 import { selectRuleValue } from '../rules/rule-registry.js';
 import { buildKernelRefFromKernelEntry, isKernelRefBoundToKernel } from '../config/kernels/kernel-ref.js';
+import { mergeLayeredShallowObjects } from '../config/merge-helpers.js';
+import { buildExecutionV0ContractArtifact } from '../config/execution-v0-contract-check.js';
 
 const KNOWN_MODEL_PRESETS = new Set(listPresets());
 const CONVERSION_SUPPORTED_PRESETS = [...KNOWN_MODEL_PRESETS]
@@ -179,9 +181,6 @@ export function validateDefaultKernelPath(inference, context = {}) {
     && expectedComputeDtype !== kernelActivationDtype
   ) {
     const presetId = context?.presetId ?? 'unknown';
-    if (presetId === 'lfm2' && expectedComputeDtype === 'f32' && kernelActivationDtype === 'f16') {
-      return;
-    }
     throw new Error(
       `Invalid defaultKernelPath "${inference.defaultKernelPath}" for preset "${presetId}" ` +
       `(weights=${quantizationInfo?.weights ?? 'unknown'}, compute=${expectedComputeDtype}, ` +
@@ -208,6 +207,61 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
+function mergeExecutionV0SessionDefaults(baseSessionDefaults, overrideSessionDefaults) {
+  if (!overrideSessionDefaults) {
+    return cloneJson(baseSessionDefaults);
+  }
+  const base = cloneJson(baseSessionDefaults ?? {});
+  const override = cloneJson(overrideSessionDefaults);
+  const baseCompute = base.compute ?? {};
+  const overrideCompute = override.compute ?? {};
+
+  return {
+    ...base,
+    ...override,
+    compute: {
+      ...baseCompute,
+      ...overrideCompute,
+      defaults: mergeLayeredShallowObjects(
+        baseCompute.defaults ?? {},
+        overrideCompute.defaults ?? {}
+      ),
+      kernelProfiles: Object.prototype.hasOwnProperty.call(overrideCompute, 'kernelProfiles')
+        ? overrideCompute.kernelProfiles
+        : baseCompute.kernelProfiles,
+    },
+    kvcache: Object.prototype.hasOwnProperty.call(override, 'kvcache')
+      ? (
+          override.kvcache === null
+            ? null
+            : mergeLayeredShallowObjects(base.kvcache ?? {}, override.kvcache ?? {})
+        )
+      : base.kvcache,
+    decodeLoop: Object.prototype.hasOwnProperty.call(override, 'decodeLoop')
+      ? (
+          override.decodeLoop === null
+            ? null
+            : mergeLayeredShallowObjects(base.decodeLoop ?? {}, override.decodeLoop ?? {})
+        )
+      : base.decodeLoop,
+  };
+}
+
+function assertExecutionV0ConversionContract(manifestInference, modelId) {
+  if (!manifestInference?.execution) {
+    return;
+  }
+  const artifact = buildExecutionV0ContractArtifact(manifestInference, {
+    modelId: modelId ?? 'converted-model',
+  });
+  if (!artifact?.ok) {
+    const detail = artifact?.errors?.join(' ') ?? 'unknown execution-v0 contract error';
+    throw new Error(
+      `converterConfig.inference produced an invalid execution-v0 contract: ${detail}`
+    );
+  }
+}
+
 function readConverterSessionDefaultsOverride(converterConfig) {
   const raw = converterConfig?.inference?.sessionDefaults;
   if (raw == null) return null;
@@ -219,6 +273,26 @@ function readConverterSessionDefaultsOverride(converterConfig) {
   return cloneJson(raw);
 }
 
+function assertNonExecutionSessionDefaults(manifestInference) {
+  const sessionDefaults = manifestInference?.sessionDefaults;
+  if (sessionDefaults == null) {
+    return;
+  }
+  if (typeof sessionDefaults !== 'object' || Array.isArray(sessionDefaults)) {
+    throw new Error(
+      'converterConfig.inference.sessionDefaults must resolve to an object for non-execution manifests.'
+    );
+  }
+  const keys = Object.keys(sessionDefaults);
+  const invalidKeys = keys.filter((key) => key !== 'decodeLoop');
+  if (invalidKeys.length > 0) {
+    throw new Error(
+      'converterConfig.inference.sessionDefaults may only set decodeLoop unless ' +
+      'converterConfig.inference.execution is present.'
+    );
+  }
+}
+
 function readConverterExecutionOverride(converterConfig) {
   const raw = converterConfig?.inference?.execution;
   if (raw == null) return null;
@@ -331,10 +405,10 @@ function applyConverterInferenceOverrides(manifestInference, converterConfig, co
     manifestInference.defaultKernelPath = overrideKernelPath;
   }
   const sessionDefaults = readConverterSessionDefaultsOverride(converterConfig);
+  const execution = readConverterExecutionOverride(converterConfig);
   if (sessionDefaults) {
     manifestInference.sessionDefaults = sessionDefaults;
   }
-  const execution = readConverterExecutionOverride(converterConfig);
   if (execution) {
     manifestInference.execution = execution;
   }
@@ -351,17 +425,28 @@ function applyConverterInferenceOverrides(manifestInference, converterConfig, co
     const generatedExecution = buildExecutionV0FromKernelPath(manifestInference.defaultKernelPath);
     if (generatedExecution) {
       manifestInference.execution = generatedExecution.execution;
-      if (!manifestInference.sessionDefaults) {
-        manifestInference.sessionDefaults = generatedExecution.sessionDefaults;
-      }
+      manifestInference.sessionDefaults = mergeExecutionV0SessionDefaults(
+        generatedExecution.sessionDefaults,
+        manifestInference.sessionDefaults
+      );
       manifestInference.schema = generatedExecution.schema;
     }
   }
 
-  if (manifestInference.execution || sessionDefaults || execution) {
+  if (execution && !manifestInference.sessionDefaults) {
+    throw new Error(
+      'converterConfig.inference.execution requires converterConfig.inference.sessionDefaults.'
+    );
+  }
+
+  if (manifestInference.execution) {
     manifestInference.schema = EXECUTION_V0_SCHEMA_ID;
+  } else {
+    assertNonExecutionSessionDefaults(manifestInference);
+    manifestInference.schema = null;
   }
   validateDefaultKernelPath(manifestInference, context);
+  assertExecutionV0ConversionContract(manifestInference, context?.modelId ?? context?.presetId);
 }
 
 export function resolveConversionPlan(options) {
@@ -418,7 +503,7 @@ export function resolveConversionPlan(options) {
   if (!presetOverride && isLikelyEmbeddingGemma(rawConfig, architectureHint)) {
     presetId = 'embeddinggemma';
   }
-  if (presetId === 'transformer') {
+  if (!presetId) {
     throw buildUnknownFamilyError(architectureHint, rawConfig, options?.includePresetOverrideHint === true);
   }
   const preset = resolvePreset(presetId);

package/src/converter/core.d.ts

@@ -168,6 +168,13 @@ export declare const RDRR_VERSION: number;
  */
 export declare function sanitizeModelId(name: string): string | null;
 
+/**
+ * Resolve bundled tokenizer vocab size from Hugging Face tokenizer.json payloads.
+ */
+export declare function resolveBundledTokenizerVocabSize(
+  tokenizerJson: Record<string, unknown> | null | undefined
+): number;
+
 /**
  * Format bytes for human-readable display
  */

package/src/converter/core.js

@@ -26,6 +26,7 @@ import { buildManifestRequiredInferenceFieldsArtifact } from '../config/required
 import { buildManifestInference, inferEmbeddingOutputConfig } from './manifest-inference.js';
 import { resolveEosTokenId } from './tokenizer-utils.js';
 import {
+  normalizeQ4KLayout,
   resolveManifestQuantization,
   resolveEffectiveQuantizationInfo,
 } from './quantization-info.js';
@@ -122,11 +123,6 @@ function bf16ToFloat32(value) {
   return view.getFloat32(0, true);
 }
 
-function normalizeQ4KLayout(value) {
-  const normalized = String(value || '').trim().toLowerCase();
-  return normalized === 'col' ? 'col' : 'row';
-}
-
 function normalizeTensorName(tensor) {
   const name = tensor?.name;
   return typeof name === 'string' ? name : '';
@@ -495,6 +491,17 @@ function buildSentencepieceTokenizer(tokenizerConfig, rawConfig, architecture, m
   return tokenizer;
 }
 
+export function resolveBundledTokenizerVocabSize(tokenizerJson) {
+  const vocab = tokenizerJson?.model?.vocab;
+  if (Array.isArray(vocab)) {
+    return vocab.length;
+  }
+  if (vocab && typeof vocab === 'object') {
+    return Object.keys(vocab).length;
+  }
+  return 0;
+}
+
 
 export function sanitizeModelId(name) {
   const sanitized = name
@@ -988,7 +995,7 @@ export function createManifest(
       inference = { ...DEFAULT_MANIFEST_INFERENCE, presetId: 'diffusion' };
     } else {
       const presetId = detectPreset(rawConfig, model.architecture);
-      if (presetId === 'transformer') {
+      if (!presetId) {
         const modelType = rawConfig.model_type ?? 'unknown';
         throw new Error(
           `Unknown model family: architecture="${model.architecture || 'unknown'}", model_type="${modelType}"\n\n` +
@@ -1070,9 +1077,7 @@ export function createManifest(
   // Include tokenizer if available
   if (model.tokenizerJson) {
     const tokenizer = model.tokenizerJson;
-    const vocabSize =
-      tokenizer.model?.vocab?.length ||
-      Object.keys(tokenizer.model?.vocab || {}).length;
+    const vocabSize = resolveBundledTokenizerVocabSize(tokenizer);
     if (!vocabSize) {
       throw new Error('Tokenizer vocab is missing or empty');
     }

package/src/converter/execution-v0-manifest.js

@@ -104,7 +104,10 @@ function buildKernelProfiles(steps) {
 }
 
 function buildSessionDefaults(kernelPath) {
-  const activationDtype = normalizeKernelDtype(getKernelPathActivationDtype(kernelPath)) ?? 'f16';
+  const activationDtype = normalizeKernelDtype(getKernelPathActivationDtype(kernelPath));
+  if (!activationDtype) {
+    throw new Error('execution-v0 manifest: kernel path is missing activationDtype.');
+  }
   const outputDtype = normalizeKernelDtype(getKernelPathOutputDtype(kernelPath)) ?? activationDtype;
   const kvDtype = normalizeKernelDtype(getKernelPathKVDtype(kernelPath)) ?? activationDtype;
   return {

package/src/converter/index.d.ts

@@ -28,6 +28,7 @@ export {
   RDRR_VERSION,
   ConvertStage,
   sanitizeModelId,
+  resolveBundledTokenizerVocabSize,
   formatBytes,
   shouldQuantize,
   normalizeStorageQuant,

package/src/converter/index.js

@@ -6,6 +6,7 @@ export {
   RDRR_VERSION,
   ConvertStage,
   sanitizeModelId,
+  resolveBundledTokenizerVocabSize,
   formatBytes,
   shouldQuantize,
   normalizeStorageQuant,

package/src/converter/manifest-inference.js

@@ -268,6 +268,19 @@ function resolveQueryPreAttnScalar(preset, modelConfig, headDim) {
   return Math.sqrt(headDim);
 }
 
+function detectRmsNormWeightOffset(presetInference, modelConfig, defaults) {
+  const modelType = normalizeLayerTypeName(modelConfig?.model_type);
+  if (modelType === 'qwen3_5' || modelType === 'qwen3_5_text') {
+    return true;
+  }
+
+  if (typeof presetInference?.normalization?.rmsNormWeightOffset === 'boolean') {
+    return presetInference.normalization.rmsNormWeightOffset;
+  }
+
+  return defaults.normalization.rmsNormWeightOffset;
+}
+
 // Build normalization config with auto-detection from tensor names.
 // Priority: auto-detected > preset > default
 function buildNormalizationConfig(presetInference, modelConfig, defaults, tensorNames) {
@@ -278,7 +291,7 @@ function buildNormalizationConfig(presetInference, modelConfig, defaults, tensor
       modelConfig.rms_norm_eps ??
       modelConfig.attentionLayerNormRMSEpsilon ??
       defaults.normalization.rmsNormEps,
-    rmsNormWeightOffset: presetInference.normalization?.rmsNormWeightOffset ?? defaults.normalization.rmsNormWeightOffset,
+    rmsNormWeightOffset: detectRmsNormWeightOffset(presetInference, modelConfig, defaults),
     // For norm flags: auto-detected > preset > default
     postAttentionNorm: detected.postAttentionNorm ?? presetInference.normalization?.postAttentionNorm ?? defaults.normalization.postAttentionNorm,
     preFeedforwardNorm: detected.preFeedforwardNorm ?? presetInference.normalization?.preFeedforwardNorm ?? defaults.normalization.preFeedforwardNorm,
@@ -303,26 +316,44 @@ function resolveKernelPathFromPreset(presetInference, quantizationInfo, q4kLayou
   }
 
   const weightKey = normalizeKernelDtype(quantizationInfo?.weights);
-  const computeKey = normalizeKernelDtype(quantizationInfo?.compute) ?? (quantizationInfo ? 'f16' : null);
-
-  const entry = (weightKey && kernelPaths[weightKey]) || kernelPaths.default;
+  const computeKey = normalizeKernelDtype(quantizationInfo?.compute);
+  const hasWeightEntry = weightKey != null && Object.prototype.hasOwnProperty.call(kernelPaths, weightKey);
+  const entry = hasWeightEntry ? kernelPaths[weightKey] : kernelPaths.default;
+  const weightLabel = weightKey ? `.${weightKey}` : '';
   let resolved = null;
+  if (entry == null) {
+    return presetInference?.kernelPath ?? null;
+  }
+
   if (typeof entry === 'string') {
     resolved = entry;
-  } else if (entry && computeKey && entry[computeKey]) {
+  } else if (entry && computeKey && Object.prototype.hasOwnProperty.call(entry, computeKey)) {
     resolved = entry[computeKey];
-  } else if (entry && entry.default) {
+  } else if (entry && typeof entry === 'object' && !Array.isArray(entry) && Object.prototype.hasOwnProperty.call(entry, 'default')) {
     resolved = entry.default;
+  } else if (entry && typeof entry === 'object' && !Array.isArray(entry) && !computeKey) {
+    throw new Error(
+      `Preset kernelPaths${weightLabel} requires quantizationInfo.compute ` +
+      'to resolve a compute-specific defaultKernelPath.'
+    );
+  } else if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+    throw new Error(
+      `Preset kernelPaths${weightLabel} is missing compute "${computeKey}". ` +
+      'Add an explicit compute-specific mapping or default instead of relying on JS fallbacks.'
+    );
   } else {
-    resolved = presetInference?.kernelPath ?? null;
+    throw new Error(
+      `Preset kernelPaths${weightLabel} must resolve to a string or object.`
+    );
   }
 
-  // When q4kLayout is 'col' (column-wise), fused Q4K kernels cannot be used.
-  // Try to find a corresponding dequant kernel path.
+  // Column-wise Q4K must be mapped explicitly in preset JSON; JS must not
+  // rewrite kernel-path ids to infer policy.
   if (resolved && q4kLayout === 'col' && resolved.includes('-fused-')) {
-    const dequantPath = resolved.replace('-fused-', '-dequant-');
-    // Return dequant variant (caller should verify it exists)
-    return dequantPath;
+    throw new Error(
+      `Preset kernelPaths${weightKey ? `.${weightKey}` : ''} resolved fused kernel path "${resolved}" ` +
+      'for q4k layout "col". Add an explicit dequant kernel path mapping to the preset instead of relying on JS rewrites.'
+    );
   }
 
   return resolved;

package/src/converter/parsers/diffusion.js

@@ -261,9 +261,6 @@ export async function parseDiffusionModel(adapter) {
     }
     const configSuffix = defaultConfigPath(componentId);
     const config = await readJson(configSuffix, `${componentId} config`);
-    if (componentId === 'transformer' && config && !config.weight_format) {
-      config.weight_format = 'diffusers';
-    }
     diffusionConfig.components[componentId] = {
       ...(diffusionConfig.components[componentId] || {}),
       config,

package/src/converter/quantization-info.js

@@ -91,6 +91,7 @@ export function buildVariantTag(info) {
   const weights = info.weights;
   const embeddings = info.embeddings ?? weights;
   const lmHead = info.lmHead ?? embeddings;
+  const compute = info.compute ? normalizeQuantTag(info.compute) : null;
   const experts = info.experts ?? null;
   const layout = info.layout ?? null;
 
@@ -100,30 +101,42 @@ export function buildVariantTag(info) {
     ? `${weights}${layout === 'row' ? '' : '-col'}`
     : weights;
 
-  const parts = [`w${weightTag}`];
+  const parts = [weightTag];
+  const groupedRolesByDtype = new Map();
+  const GROUPED_ROLE_ORDER = ['e', 'h', 'a'];
 
-  if (embeddings !== weights) {
-    parts.push(`e${embeddings}`);
-  }
+  const addGroupedRole = (role, dtype) => {
+    if (!dtype || dtype === weights) return;
+    const existing = groupedRolesByDtype.get(dtype) ?? [];
+    if (!existing.includes(role)) {
+      existing.push(role);
+      groupedRolesByDtype.set(dtype, existing);
+    }
+  };
 
-  if (lmHead !== embeddings) {
-    parts.push(`h${lmHead}`);
+  addGroupedRole('e', embeddings);
+  addGroupedRole('h', lmHead);
+  addGroupedRole('a', compute);
+
+  for (const [dtype, roles] of groupedRolesByDtype.entries()) {
+    const orderedRoles = GROUPED_ROLE_ORDER.filter((role) => roles.includes(role));
+    parts.push(`${orderedRoles.join('')}${dtype}`);
   }
 
   if (experts && experts !== weights) {
     parts.push(`x${experts}`);
   }
 
-  if (info.vision) {
+  if (info.vision && info.vision !== weights) {
     parts.push(`v${info.vision}`);
   }
-  if (info.audio) {
-    parts.push(`a${info.audio}`);
+  if (info.audio && info.audio !== weights) {
+    parts.push(`audio${info.audio}`);
   }
-  if (info.tts) {
-    parts.push(`t${info.tts}`);
+  if (info.tts && info.tts !== weights) {
+    parts.push(`tts${info.tts}`);
   }
-  if (info.projector) {
+  if (info.projector && info.projector !== weights) {
     parts.push(`p${info.projector}`);
   }
 
@@ -167,9 +180,16 @@ const Q4K_LAYOUT_ALIASES = {
 };
 
 export function normalizeQ4KLayout(value) {
-  if (!value) return null;
-  const lower = String(value).toLowerCase().replace(/_/g, '');
-  return Q4K_LAYOUT_ALIASES[lower] ?? null;
+  if (value == null) return null;
+  const lower = String(value).trim().toLowerCase().replace(/_/g, '');
+  if (!lower) return null;
+  const normalized = Q4K_LAYOUT_ALIASES[lower];
+  if (!normalized) {
+    throw new Error(
+      `converter.quantization.q4kLayout must be "row" or "col"; got ${JSON.stringify(value)}.`
+    );
+  }
+  return normalized;
 }
 
 export function buildQuantizationInfo(

package/src/converter/rope-config.js

@@ -6,10 +6,26 @@ function asObject(value) {
 }
 
 function asFiniteNumber(value) {
+  if (value == null || value === '') {
+    return null;
+  }
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : null;
 }
 
+function asBoolean(value) {
+  return typeof value === 'boolean' ? value : null;
+}
+
+function asNumberArray(value) {
+  if (!Array.isArray(value)) return null;
+  const normalized = value.map((entry) => asFiniteNumber(entry));
+  if (normalized.some((entry) => entry == null || entry <= 0)) {
+    return null;
+  }
+  return normalized.map((entry) => Math.trunc(entry));
+}
+
 function normalizeRoPEType(value) {
   if (typeof value !== 'string') return null;
   const normalized = value.trim().toLowerCase();
@@ -125,6 +141,13 @@ function failOnConflictingScaling(sourceLabel, canonicalScaling, candidateScalin
 export function buildRoPEConfig(presetInference, config) {
   const ropeScaling = asObject(config.rope_scaling);
   const ropeParameters = asObject(config.rope_parameters);
+  const flatRoPEParameters = (
+    ropeParameters
+      && !asObject(ropeParameters.full_attention)
+      && !asObject(ropeParameters.sliding_attention)
+  )
+    ? ropeParameters
+    : null;
   const fullAttentionRoPE = asObject(ropeParameters?.full_attention);
   const slidingAttentionRoPE = asObject(ropeParameters?.sliding_attention);
   const presetRoPE = presetInference.rope ?? {};
@@ -164,6 +187,11 @@ export function buildRoPEConfig(presetInference, config) {
       strictMissingTypeAndFactor: false,
       sourceLabel: 'HF config rope_parameters.full_attention',
     });
+  } else if (flatRoPEParameters) {
+    globalScaling = resolveScalingConfig(flatRoPEParameters, {
+      strictMissingTypeAndFactor: false,
+      sourceLabel: 'HF config rope_parameters',
+    });
   }
 
   const hasPresetLocalScaling = presetRoPE.ropeLocalScalingType !== undefined
@@ -192,6 +220,7 @@ export function buildRoPEConfig(presetInference, config) {
   // HF config is source of truth for ropeTheta when provided:
   // prefer rope_parameters.full_attention.rope_theta, then rope_theta.
   const ropeTheta = asFiniteNumber(fullAttentionRoPE?.rope_theta)
+    ?? asFiniteNumber(flatRoPEParameters?.rope_theta)
     ?? asFiniteNumber(config.rope_theta)
     ?? presetInference.rope?.ropeTheta
     ?? 10000;
@@ -201,9 +230,22 @@ export function buildRoPEConfig(presetInference, config) {
     ?? presetInference.rope?.ropeLocalTheta
     ?? null;
 
+  const mropeInterleaved = asBoolean(flatRoPEParameters?.mrope_interleaved)
+    ?? presetInference.rope?.mropeInterleaved
+    ?? false;
+  const mropeSection = asNumberArray(flatRoPEParameters?.mrope_section)
+    ?? presetInference.rope?.mropeSection
+    ?? null;
+  const partialRotaryFactor = asFiniteNumber(flatRoPEParameters?.partial_rotary_factor)
+    ?? asFiniteNumber(presetInference.rope?.partialRotaryFactor)
+    ?? null;
+
   return {
     ropeTheta,
     ropeLocalTheta,
+    mropeInterleaved,
+    mropeSection,
+    partialRotaryFactor,
     ropeScalingType: globalScaling.ropeScalingType,
     ropeScalingFactor: globalScaling.ropeScalingFactor,
     yarnBetaFast: globalScaling.yarnBetaFast,

package/src/converter/shard-packer.d.ts

@@ -126,7 +126,7 @@ export declare class ShardPacker {
  */
 export declare function sortTensorsByGroup(
   tensors: TensorInfoSchema[],
-  modelType?: ModelType
+  modelType: ModelType
 ): TensorInfoSchema[];
 
 /**

package/src/converter/shard-packer.js

@@ -399,7 +399,10 @@ function bytesToHex(bytes) {
 }
 
 
-export function sortTensorsByGroup(tensors, modelType = 'transformer') {
+export function sortTensorsByGroup(tensors, modelType) {
+  if (typeof modelType !== 'string' || modelType.trim().length === 0) {
+    throw new Error('sortTensorsByGroup requires an explicit modelType.');
+  }
   return [...tensors].sort((a, b) => {
     const groupA = classifyTensor(a.name, modelType);
     const groupB = classifyTensor(b.name, modelType);