@simulatte/doppler 0.1.6 → 0.1.8

package/src/config/schema/manifest.schema.js

@@ -1,4 +1,5 @@
 import { MB } from './units.schema.js';
+import { validateRequiredInferenceFields } from '../../inference/pipelines/text/config.js';
 
 // =============================================================================
 // Hash & Versioning
@@ -39,7 +40,7 @@ export const DEFAULT_MANIFEST_INFERENCE = {
   schema: null,
   presetId: null,
   attention: {
-    queryPreAttnScalar: 8,  // sqrt(64) for standard 64-dim heads
+    queryPreAttnScalar: 64, // headDim for standard 64-dim heads; attnScale = 1/sqrt(scalar)
     attnLogitSoftcapping: null,  // No softcapping (null = disabled)
     slidingWindow: null,  // Full attention (null = no sliding window)
     queryKeyNorm: false,
@@ -70,9 +71,9 @@ export const DEFAULT_MANIFEST_INFERENCE = {
     ropeLocalScalingType: null,  // Local scaling policy (null = no scaling)
     ropeLocalScalingFactor: 1.0,
     // YARN parameters - only relevant when ropeScalingType='yarn'
-    yarnBetaFast: 32,
-    yarnBetaSlow: 1,
-    yarnOriginalMaxPos: 4096,
+    yarnBetaFast: null,
+    yarnBetaSlow: null,
+    yarnOriginalMaxPos: null,
     // Local YARN parameters - only relevant when ropeLocalScalingType='yarn'
     ropeLocalYarnBetaFast: null,
     ropeLocalYarnBetaSlow: null,
@@ -124,6 +125,18 @@ export function validateManifestInference(
       `Please re-convert the model using the latest converter.`
     );
   }
+
+  if (manifest.modelType === 'diffusion' || manifest.modelType === 'energy') {
+    return;
+  }
+
+  const inference = typeof structuredClone === 'function'
+    ? structuredClone(manifest.inference)
+    : JSON.parse(JSON.stringify(manifest.inference));
+  validateRequiredInferenceFields(
+    inference,
+    manifest.modelId ?? 'unknown'
+  );
 }
 
 export function hasInferenceConfig(

package/src/config/schema/storage.schema.js

@@ -35,7 +35,7 @@ export const DEFAULT_STORAGE_ALIGNMENT_CONFIG = {
 export const DEFAULT_STORAGE_BACKEND_CONFIG = {
   backend: 'auto', // auto | opfs | indexeddb | memory
   opfs: {
-    useSyncAccessHandle: true,
+    useSyncAccessHandle: false,
     maxConcurrentHandles: 2,
   },
   indexeddb: {

package/src/config/training-defaults.js

@@ -2,9 +2,17 @@ import { createDopplerConfig, DEFAULT_TRAINING_SETTINGS } from './schema/index.j
 import { validateDistillTrainingConfig } from './schema/distill-training.schema.js';
 import { validateUlTrainingConfig } from './schema/ul-training.schema.js';
 
+function cloneConfigTree(value) {
+  if (typeof structuredClone === 'function') {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
 function mergeTrainingSettings(base, overrides) {
+  const baseConfig = cloneConfigTree(base);
   if (!overrides) {
-    const merged = { ...base };
+    const merged = baseConfig;
     validateDistillTrainingConfig(merged.distill);
     validateUlTrainingConfig(merged.ul);
     if (merged.distill.enabled === true && merged.ul.enabled === true) {
@@ -14,42 +22,42 @@ function mergeTrainingSettings(base, overrides) {
   }
 
   const merged = {
-    enabled: overrides.enabled ?? base.enabled,
-    lora: { ...base.lora, ...overrides.lora },
+    enabled: overrides.enabled ?? baseConfig.enabled,
+    lora: { ...baseConfig.lora, ...overrides.lora },
     optimizer: {
-      ...base.optimizer,
+      ...baseConfig.optimizer,
       ...overrides.optimizer,
-      scheduler: { ...base.optimizer.scheduler, ...overrides.optimizer?.scheduler },
+      scheduler: { ...baseConfig.optimizer.scheduler, ...overrides.optimizer?.scheduler },
     },
-    gradient: { ...base.gradient, ...overrides.gradient },
-    precision: { ...base.precision, ...overrides.precision },
-    attention: { ...base.attention, ...overrides.attention },
+    gradient: { ...baseConfig.gradient, ...overrides.gradient },
+    precision: { ...baseConfig.precision, ...overrides.precision },
+    attention: { ...baseConfig.attention, ...overrides.attention },
     telemetry: {
-      ...base.telemetry,
+      ...baseConfig.telemetry,
       ...overrides.telemetry,
       alerts: {
-        ...base.telemetry.alerts,
+        ...baseConfig.telemetry.alerts,
         ...overrides.telemetry?.alerts,
         thresholds: {
-          ...base.telemetry.alerts.thresholds,
+          ...baseConfig.telemetry.alerts.thresholds,
           ...overrides.telemetry?.alerts?.thresholds,
         },
       },
     },
-    lossScaling: { ...base.lossScaling, ...overrides.lossScaling },
+    lossScaling: { ...baseConfig.lossScaling, ...overrides.lossScaling },
     distill: {
-      ...base.distill,
+      ...baseConfig.distill,
       ...overrides.distill,
-      freeze: { ...base.distill.freeze, ...overrides.distill?.freeze },
+      freeze: { ...baseConfig.distill.freeze, ...overrides.distill?.freeze },
     },
     ul: {
-      ...base.ul,
+      ...baseConfig.ul,
       ...overrides.ul,
-      noiseSchedule: { ...base.ul.noiseSchedule, ...overrides.ul?.noiseSchedule },
-      priorAlignment: { ...base.ul.priorAlignment, ...overrides.ul?.priorAlignment },
-      decoderSigmoidWeight: { ...base.ul.decoderSigmoidWeight, ...overrides.ul?.decoderSigmoidWeight },
-      lossWeights: { ...base.ul.lossWeights, ...overrides.ul?.lossWeights },
-      freeze: { ...base.ul.freeze, ...overrides.ul?.freeze },
+      noiseSchedule: { ...baseConfig.ul.noiseSchedule, ...overrides.ul?.noiseSchedule },
+      priorAlignment: { ...baseConfig.ul.priorAlignment, ...overrides.ul?.priorAlignment },
+      decoderSigmoidWeight: { ...baseConfig.ul.decoderSigmoidWeight, ...overrides.ul?.decoderSigmoidWeight },
+      lossWeights: { ...baseConfig.ul.lossWeights, ...overrides.ul?.lossWeights },
+      freeze: { ...baseConfig.ul.freeze, ...overrides.ul?.freeze },
     },
   };
   validateDistillTrainingConfig(merged.distill);
@@ -74,7 +82,7 @@ export function createTrainingConfig(overrides = {}) {
 
 export const DEFAULT_TRAINING_CONFIG = createTrainingConfig();
 
-let trainingConfig = DEFAULT_TRAINING_CONFIG;
+let trainingConfig = createTrainingConfig();
 
 export function getTrainingConfig() {
   return trainingConfig;
@@ -86,6 +94,6 @@ export function setTrainingConfig(overrides) {
 }
 
 export function resetTrainingConfig() {
-  trainingConfig = DEFAULT_TRAINING_CONFIG;
+  trainingConfig = createTrainingConfig();
   return trainingConfig;
 }

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]
@@ -115,7 +117,10 @@ function isLikelyEmbeddingGemma(rawConfig, architectureHint) {
 
 export function inferSourceWeightQuantization(tensors) {
   if (!Array.isArray(tensors) || tensors.length === 0) {
-    return 'f16';
+    throw new Error(
+      'Cannot infer source weight quantization: no tensors provided. ' +
+      'Set converterConfig.quantization.weights explicitly.'
+    );
   }
   const weightTensors = [];
   for (const tensor of tensors) {
@@ -126,7 +131,12 @@ export function inferSourceWeightQuantization(tensors) {
     weightTensors.push({ name, dtype });
   }
   const dtypes = new Set(weightTensors.map((tensor) => tensor.dtype));
-  if (dtypes.size === 0) return 'f16';
+  if (dtypes.size === 0) {
+    throw new Error(
+      'Cannot infer source weight quantization: no recognizable weight dtypes found. ' +
+      'Set converterConfig.quantization.weights explicitly.'
+    );
+  }
   if (dtypes.size > 1) {
     const detail = Array.from(dtypes)
       .sort()
@@ -179,9 +189,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 +215,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 +281,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 +413,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 +433,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 +511,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
@@ -976,6 +983,7 @@ export function createManifest(
     isDiffusion ? 'diffusion' : extractArchitecture(model.config, model.ggufConfig)
   );
   const rawConfig = model.config || {};
+  const generationConfig = model.generationConfig ?? null;
   const resolvedArchitecture = isDiffusion
     ? architecture
     : resolveIntermediateSizeFromTensors(architecture, model, tensorLocations, rawConfig, modelId);
@@ -988,7 +996,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` +
@@ -1030,6 +1038,7 @@ export function createManifest(
       ? null
       : resolveEosTokenId({
           config: rawConfig,
+          generationConfig,
           tokenizer: model.tokenizer ?? model.tokenizerConfig ?? null,
           tokenizerJson: model.tokenizerJson ?? null,
         });
@@ -1070,9 +1079,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

@@ -240,16 +240,6 @@ function detectAttentionOutputGate(presetInference, modelConfig, defaults) {
     return modelConfig.attn_output_gate;
   }
 
-  const modelType = normalizeLayerTypeName(modelConfig?.model_type);
-  const hasLinearAttentionLayers = Array.isArray(modelConfig?.layer_types)
-    && modelConfig.layer_types.some((entry) => normalizeCustomLayerType(entry) === 'linear_attention');
-  if (
-    hasLinearAttentionLayers
-    && (modelType === 'qwen2' || modelType === 'qwen3_5' || modelType === 'qwen3_5_text')
-  ) {
-    return true;
-  }
-
   return defaults.attention.attentionOutputGate;
 }
 
@@ -259,13 +249,23 @@ function resolveQueryPreAttnScalar(preset, modelConfig, headDim) {
     return explicit;
   }
 
-  const modelType = normalizeLayerTypeName(modelConfig?.model_type);
-  const presetId = normalizeLayerTypeName(preset?.id);
-  if (modelType.startsWith('qwen') || presetId === 'qwen3') {
-    return headDim;
+  // Standard attention scaling: attnScale = 1/sqrt(queryPreAttnScalar).
+  // For standard transformers queryPreAttnScalar = headDim, giving 1/sqrt(headDim).
+  // Preset may override for non-standard models.
+  const presetScalar = Number(preset?.inference?.attention?.queryPreAttnScalar);
+  if (Number.isFinite(presetScalar) && presetScalar > 0) {
+    return presetScalar;
+  }
+
+  return headDim;
+}
+
+function detectRmsNormWeightOffset(presetInference, modelConfig, defaults) {
+  if (typeof presetInference?.normalization?.rmsNormWeightOffset === 'boolean') {
+    return presetInference.normalization.rmsNormWeightOffset;
   }
 
-  return Math.sqrt(headDim);
+  return defaults.normalization.rmsNormWeightOffset;
 }
 
 // Build normalization config with auto-detection from tensor names.
@@ -278,7 +278,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 +303,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;
@@ -354,8 +372,8 @@ export function buildManifestInference(preset, config, headDim = 64, quantizatio
       queryPreAttnScalar: resolveQueryPreAttnScalar(preset, modelConfig, headDim),
       attnLogitSoftcapping: presetInference.attention?.attnLogitSoftcapping ??
         modelConfig.attn_logit_softcapping ?? defaults.attention.attnLogitSoftcapping,
-      slidingWindow: presetInference.attention?.slidingWindow ??
-        modelConfig.sliding_window ?? defaults.attention.slidingWindow,
+      slidingWindow: modelConfig.sliding_window ??
+        presetInference.attention?.slidingWindow ?? defaults.attention.slidingWindow,
       queryKeyNorm: presetInference.attention?.queryKeyNorm ?? defaults.attention.queryKeyNorm,
       attentionOutputGate: detectAttentionOutputGate(presetInference, modelConfig, defaults),
       causal: detectedCausalAttention ?? presetInference.attention?.causal ?? defaults.attention.causal,
@@ -428,6 +446,9 @@ export function buildManifestInference(preset, config, headDim = 64, quantizatio
         );
       }
       globalPattern = null;
+      // Default offset 0 means first global layer at index 0 (most common pattern).
+      // This is the every_n pattern default, distinct from layerPattern.offset=null
+      // which means "not applicable" in the schema.
       offset = (
         detectEveryNOffsetFromLayerTypes(modelConfig.layer_types, period)
         ?? normalizeEveryNOffset(presetPattern.offset, period)

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/parsers/transformer.js

@@ -7,6 +7,9 @@ export async function parseTransformerModel(adapter) {
   } = adapter;
 
   const config = await readJson('config.json', 'config.json');
+  const generationConfig = await fileExists('generation_config.json')
+    ? await readJson('generation_config.json', 'generation_config.json')
+    : null;
   const architectureHint = config.architectures?.[0] ?? config.model_type ?? '';
 
   let tensors = null;
@@ -19,6 +22,7 @@ export async function parseTransformerModel(adapter) {
 
   return {
     config,
+    generationConfig,
     tensors,
     architectureHint,
   };