@simulatte/doppler 0.1.6 → 0.1.8

package/src/converter/quantization-info.js

@@ -2,6 +2,10 @@
 import { DEFAULT_QUANTIZATION_DEFAULTS, DEFAULT_Q4K_LAYOUT } from '../config/index.js';
 import { classifyTensorRole } from '../formats/rdrr/index.js';
 
+// Default quantization tag when no explicit dtype is provided.
+// F16 is the canonical unquantized storage format for WebGPU inference.
+const DEFAULT_QUANT_TAG = 'f16';
+
 // Quantization tag aliases mapped to canonical names.
 // Add new aliases here rather than adding if/else branches.
 const QUANT_TAG_ALIASES = {
@@ -47,7 +51,7 @@ const QUANT_TAG_ALIASES = {
 };
 
 export function normalizeQuantTag(value) {
-  if (!value) return 'f16';
+  if (!value) return DEFAULT_QUANT_TAG;
   const lower = value.toLowerCase();
   return QUANT_TAG_ALIASES[lower] ?? lower;
 }
@@ -91,6 +95,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 +105,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 +184,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/quantizer.js

@@ -74,9 +74,10 @@ function findMinMax(data, offset, length) {
   return { min, max };
 }
 
-export function quantizeQ4KBlock(data, offset) {
+function quantizeQ4KBlockWithValidLength(data, offset, validLength = QK_K) {
   const block = new Uint8Array(QK4_K_BLOCK_SIZE);
   const blockView = new DataView(block.buffer);
+  const clampedValidLength = Math.max(0, Math.min(QK_K, Math.trunc(validLength)));
 
   const scales = new Float32Array(8);
   const minOffsets = new Float32Array(8);
@@ -84,14 +85,22 @@ export function quantizeQ4KBlock(data, offset) {
 
   for (let sb = 0; sb < 8; sb++) {
     const sbOffset = offset + sb * 32;
-    const { min, max } = findMinMax(data, sbOffset, 32);
+    const subblockStart = sb * 32;
+    const validInSubblock = Math.max(0, Math.min(32, clampedValidLength - subblockStart));
+    if (validInSubblock === 0) {
+      scales[sb] = 0;
+      minOffsets[sb] = 0;
+      continue;
+    }
+
+    const { min, max } = findMinMax(data, sbOffset, validInSubblock);
 
     minOffsets[sb] = -min;
     const range = max - min;
     scales[sb] = range > 0 ? range / 15 : 0;
 
     const invScale = scales[sb] > 0 ? 1 / scales[sb] : 0;
-    for (let i = 0; i < 32; i++) {
+    for (let i = 0; i < validInSubblock; i++) {
       const val = data[sbOffset + i];
       let q = Math.round((val - min) * invScale);
       q = Math.max(0, Math.min(15, q));
@@ -155,6 +164,10 @@ export function quantizeQ4KBlock(data, offset) {
   return block;
 }
 
+export function quantizeQ4KBlock(data, offset) {
+  return quantizeQ4KBlockWithValidLength(data, offset, QK_K);
+}
+
 function dequantizeQ4KBlock(block) {
   const blockView = new DataView(block.buffer, block.byteOffset);
   const result = new Float32Array(256);
@@ -245,22 +258,16 @@ export function quantizeToQ4KMRowWise(data, shape) {
   }
 
   const blocksPerRow = Math.ceil(cols / QK_K);
-  const paddedColsPerRow = blocksPerRow * QK_K;
   const totalBlocks = rows * blocksPerRow;
 
   const quantized = new Uint8Array(totalBlocks * QK4_K_BLOCK_SIZE);
 
   for (let row = 0; row < rows; row++) {
-    // Extract and pad this row
-    const rowData = new Float32Array(paddedColsPerRow);
-    const srcOffset = row * cols;
-    for (let c = 0; c < cols; c++) {
-      rowData[c] = data[srcOffset + c];
-    }
-
     // Quantize each block in this row
     for (let b = 0; b < blocksPerRow; b++) {
-      const block = quantizeQ4KBlock(rowData, b * QK_K);
+      const validLength = Math.max(0, Math.min(QK_K, cols - b * QK_K));
+      const srcOffset = row * cols + b * QK_K;
+      const block = quantizeQ4KBlockWithValidLength(data, srcOffset, validLength);
       const dstOffset = (row * blocksPerRow + b) * QK4_K_BLOCK_SIZE;
       quantized.set(block, dstOffset);
     }

package/src/converter/rope-config.js

@@ -1,3 +1,5 @@
+import { DEFAULT_MANIFEST_INFERENCE } from '../config/schema/index.js';
+
 function asObject(value) {
   if (value == null || typeof value !== 'object' || Array.isArray(value)) {
     return null;
@@ -50,7 +52,7 @@ function resolveScalingConfig(ropeScalingConfig, options = {}) {
     }
     return {
       ropeScalingType: null,
-      ropeScalingFactor: 1.0,
+      ropeScalingFactor: DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor,
       yarnBetaFast: null,
       yarnBetaSlow: null,
       yarnOriginalMaxPos: null,
@@ -58,7 +60,7 @@ function resolveScalingConfig(ropeScalingConfig, options = {}) {
   }
 
   let ropeScalingType = scalingType;
-  let ropeScalingFactor = 1.0;
+  let ropeScalingFactor = DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor;
   let yarnBetaFast = null;
   let yarnBetaSlow = null;
   let yarnOriginalMaxPos = null;
@@ -110,7 +112,7 @@ function hasScalingDirective(ropeScalingConfig) {
 function hasMeaningfulScalingConfig(resolvedScaling) {
   if (!resolvedScaling) return false;
   return resolvedScaling.ropeScalingType != null
-    || resolvedScaling.ropeScalingFactor !== 1.0
+    || resolvedScaling.ropeScalingFactor !== DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor
     || resolvedScaling.yarnBetaFast != null
     || resolvedScaling.yarnBetaSlow != null
     || resolvedScaling.yarnOriginalMaxPos != null;
@@ -159,7 +161,7 @@ export function buildRoPEConfig(presetInference, config) {
       ?? null,
     ropeScalingFactor: presetRoPE.ropeScalingFactor
       ?? presetAttn?.ropeScalingFactor  // Deprecated location
-      ?? 1.0,
+      ?? DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor,
     yarnBetaFast: presetRoPE.yarnBetaFast ?? null,
     yarnBetaSlow: presetRoPE.yarnBetaSlow ?? null,
     yarnOriginalMaxPos: presetRoPE.yarnOriginalMaxPos ?? null,
@@ -223,7 +225,7 @@ export function buildRoPEConfig(presetInference, config) {
     ?? asFiniteNumber(flatRoPEParameters?.rope_theta)
     ?? asFiniteNumber(config.rope_theta)
     ?? presetInference.rope?.ropeTheta
-    ?? 10000;
+    ?? DEFAULT_MANIFEST_INFERENCE.rope.ropeTheta;
 
   // For Gemma 3, local sliding attention theta comes from rope_parameters.sliding_attention.
   const ropeLocalTheta = asFiniteNumber(slidingAttentionRoPE?.rope_theta)
@@ -232,7 +234,7 @@ export function buildRoPEConfig(presetInference, config) {
 
   const mropeInterleaved = asBoolean(flatRoPEParameters?.mrope_interleaved)
     ?? presetInference.rope?.mropeInterleaved
-    ?? false;
+    ?? DEFAULT_MANIFEST_INFERENCE.rope.mropeInterleaved;
   const mropeSection = asNumberArray(flatRoPEParameters?.mrope_section)
     ?? presetInference.rope?.mropeSection
     ?? null;

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);

package/src/converter/tokenizer-utils.d.ts

@@ -1,5 +1,6 @@
 export declare function resolveEosTokenId(options: {
   config?: Record<string, unknown> | null;
+  generationConfig?: Record<string, unknown> | null;
   tokenizer?: {
     eosTokenId?: number;
     eos_token_id?: number;

package/src/converter/tokenizer-utils.js

@@ -1,6 +1,8 @@
-export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
+export function resolveEosTokenId({ config, generationConfig, tokenizer, tokenizerJson }) {
   const nestedTextConfig = getNestedTextConfig(config);
   const candidateSources = [
+    generationConfig?.eos_token_id,
+    generationConfig?.eos_token_ids,
     tokenizer?.eosTokenId,
     tokenizer?.eos_token_id,
     tokenizerJson?.specialTokens?.eos,
@@ -19,6 +21,7 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
   }
 
   const eosTokenStringCandidates = [
+    generationConfig?.eos_token,
     tokenizer?.eosToken,
     tokenizer?.eos_token,
     tokenizerJson?.specialTokens?.eos_token,

package/src/debug/config.js

@@ -50,6 +50,108 @@ const originalConsoleInfo = console.info;
 const originalConsoleWarn = console.warn;
 let warnedBenchmarkMode = false;
 
+function requirePlainObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${label} must be an object when provided.`);
+  }
+  return value;
+}
+
+function requireNonNegativeIntegerArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array of non-negative integers when provided.`);
+  }
+  return value.map((entry, index) => {
+    const parsed = Number(entry);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      throw new Error(`${label}[${index}] must be a non-negative integer.`);
+    }
+    return parsed;
+  });
+}
+
+function requireNonNegativeInteger(value, label) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`${label} must be a non-negative integer when provided.`);
+  }
+  return parsed;
+}
+
+function requireBoolean(value, label) {
+  if (typeof value !== 'boolean') {
+    throw new Error(`${label} must be a boolean when provided.`);
+  }
+  return value;
+}
+
+function normalizeLogLevel(level) {
+  if (typeof level !== 'string' || !level.trim()) {
+    throw new Error('setLogLevel(level) requires a non-empty log level string.');
+  }
+  return level.trim().toLowerCase();
+}
+
+function normalizeTraceCategories(categories) {
+  if (typeof categories === 'string') {
+    const values = categories
+      .split(',')
+      .map((value) => value.trim())
+      .filter(Boolean);
+    if (values.length === 0) {
+      throw new Error('setTrace(categories) requires at least one trace category.');
+    }
+    return values;
+  }
+  if (Array.isArray(categories) && categories.length > 0) {
+    return categories.map((value, index) => {
+      if (typeof value !== 'string' || !value.trim()) {
+        throw new Error(`setTrace(categories)[${index}] must be a non-empty string.`);
+      }
+      return value.trim();
+    });
+  }
+  throw new Error(
+    'setTrace(categories) requires false, a comma-delimited string, or a non-empty string array.'
+  );
+}
+
+function validateTraceCategoryToken(token) {
+  if (token === 'all') {
+    return;
+  }
+  const value = token.startsWith('-') ? token.slice(1) : token;
+  if (!TRACE_CATEGORIES.includes(value)) {
+    throw new Error(
+      `Unknown trace category "${token}". Allowed categories: all, ${TRACE_CATEGORIES.join(', ')}.`
+    );
+  }
+}
+
+function normalizeTraceOptions(options) {
+  if (options == null) {
+    return {};
+  }
+  const normalized = requirePlainObject(options, 'setTrace(options)');
+  return {
+    ...(normalized.layers === undefined ? {} : {
+      layers: requireNonNegativeIntegerArray(normalized.layers, 'setTrace(options).layers'),
+    }),
+    ...(normalized.maxDecodeSteps === undefined ? {} : {
+      maxDecodeSteps: requireNonNegativeInteger(
+        normalized.maxDecodeSteps,
+        'setTrace(options).maxDecodeSteps'
+      ),
+    }),
+    ...(normalized.breakOnAnomaly === undefined ? {} : {
+      breakOnAnomaly: requireBoolean(
+        normalized.breakOnAnomaly,
+        'setTrace(options).breakOnAnomaly'
+      ),
+    }),
+  };
+}
+
 export function setLogLevel(level) {
   const levelMap = {
     debug: LOG_LEVELS.DEBUG,
@@ -59,8 +161,14 @@ export function setLogLevel(level) {
     error: LOG_LEVELS.ERROR,
     silent: LOG_LEVELS.SILENT,
   };
-  currentLogLevel = levelMap[level.toLowerCase()] ?? LOG_LEVELS.INFO;
-  console.log(`[Doppler] Log level set to: ${level.toUpperCase()}`);
+  const normalizedLevel = normalizeLogLevel(level);
+  if (!Object.prototype.hasOwnProperty.call(levelMap, normalizedLevel)) {
+    throw new Error(
+      `Unknown log level "${level}". Allowed levels: ${Object.keys(levelMap).join(', ')}.`
+    );
+  }
+  currentLogLevel = levelMap[normalizedLevel];
+  console.log(`[Doppler] Log level set to: ${normalizedLevel.toUpperCase()}`);
 }
 
 export function getLogLevel() {
@@ -77,9 +185,11 @@ export function setTrace(categories, options) {
     return;
   }
 
-  const catArray = typeof categories === 'string'
-    ? categories.split(',').map(s => s.trim())
-    : categories;
+  const catArray = normalizeTraceCategories(categories);
+  const traceOptions = normalizeTraceOptions(options);
+  for (const cat of catArray) {
+    validateTraceCategoryToken(cat);
+  }
 
   enabledTraceCategories.clear();
 
@@ -101,14 +211,14 @@ export function setTrace(categories, options) {
     }
   }
 
-  if (options?.layers) {
-    traceLayerFilter = options.layers;
+  if (traceOptions.layers !== undefined) {
+    traceLayerFilter = traceOptions.layers;
   }
-  if (options?.maxDecodeSteps !== undefined) {
-    traceMaxDecodeSteps = options.maxDecodeSteps;
+  if (traceOptions.maxDecodeSteps !== undefined) {
+    traceMaxDecodeSteps = traceOptions.maxDecodeSteps;
   }
-  if (options?.breakOnAnomaly !== undefined) {
-    traceBreakOnAnomaly = options.breakOnAnomaly;
+  if (traceOptions.breakOnAnomaly !== undefined) {
+    traceBreakOnAnomaly = traceOptions.breakOnAnomaly;
   }
 
   const enabled = [...enabledTraceCategories].join(',') || 'none';
@@ -184,11 +294,13 @@ export function setSilentMode(enabled) {
     console.log = noop;
     console.debug = noop;
     console.info = noop;
+    console.warn = noop;
     originalConsoleLog('[Doppler] Silent mode enabled - logging silenced');
   } else {
     console.log = originalConsoleLog;
     console.debug = originalConsoleDebug;
     console.info = originalConsoleInfo;
+    console.warn = originalConsoleWarn;
     console.log('[Doppler] Silent mode disabled - logging restored');
   }
 }