@simulatte/doppler 0.1.7 → 0.1.9

package/src/loader/tensors/tensor-loader.js

@@ -1,7 +1,7 @@
 
 
 import { getDevice, getKernelCapabilities } from '../../gpu/device.js';
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
+import { acquireBuffer, releaseBuffer, readBuffer } from '../../memory/buffer-pool.js';
 import { dequantize, dequantizeRowwise, dequantizeQ6K, castF16ToF32, runBF16ToF16 } from '../../gpu/kernel-selector.js';
 import { createTensor } from '../../gpu/tensor.js';
 import { createWeightBuffer } from '../../gpu/weight-buffer.js';
@@ -9,6 +9,7 @@ import { f16ToF32, convertBF16ToF32GPU, shouldDequantizeToF16, applyBufferLayout
 import { QK_K, Q4K_BLOCK_BYTES, Q6K_BLOCK_BYTES } from '../quantization-constants.js';
 import { log, trace as debugTrace } from '../../debug/index.js';
 import { selectRuleValue } from '../../rules/rule-registry.js';
+import { dequantizeQ4KM, dequantizeQ4KMRowWise } from '../../converter/quantizer.js';
 
 // ============================================================================
 // Q4K Detection
@@ -31,6 +32,24 @@ function releaseOwnedGpuBuffer(buffer, owned) {
   releaseBuffer(buffer);
 }
 
+function normalizeLoaderDebugConfig(config) {
+  const debug = config?.loaderDebug;
+  if (!debug || typeof debug !== 'object') {
+    return null;
+  }
+
+  return {
+    enabled: debug.enabled === true,
+    forceGpuDequant: debug.forceGpuDequant === true,
+    preferCpuDequant: debug.preferCpuDequant === true,
+    failOnCpuDequantPath: debug.failOnCpuDequantPath === true,
+    runQ4KDequantParity: debug.runQ4KDequantParity === true,
+    q4kDequantParitySamples: Number.isFinite(debug.q4kDequantParitySamples)
+      ? Math.min(4096, Math.max(1, Math.trunc(debug.q4kDequantParitySamples)))
+      : 256,
+  };
+}
+
 function logF32UpcastNonMatmul(name, numElements, bufferSize) {
   if (loggedF32UpcastNonMatmul) {
     return;
@@ -199,11 +218,52 @@ export async function loadQ4KDequant(shardData, location, name, config) {
     }
 
     const outputDtype = getQ4KOutputDtype(location, config);
+    const loaderDebug = normalizeLoaderDebugConfig(config);
+    const debugEnabled = loaderDebug?.enabled === true;
+    const forceGpuDequant = loaderDebug?.forceGpuDequant === true;
+    const failOnCpuDequantPath = loaderDebug?.failOnCpuDequantPath === true;
+    const runQ4KDequantParity = loaderDebug?.runQ4KDequantParity === true;
+    const paritySamples = loaderDebug?.q4kDequantParitySamples ?? 256;
 
     const is2DMatrix = Array.isArray(location.shape) && location.shape.length === 2;
     const K = is2DMatrix ? location.shape[1] : 0;
     const needsRowwise = is2DMatrix && K > 0 && K % QK_K !== 0;
+    const layout = getWeightLayout(location, config);
+    const preferCpuDequant = loaderDebug?.preferCpuDequant === true;
+    const canUseCpuReference = !forceGpuDequant && preferCpuDequant && (
+      outputDtype === 'f32'
+      && !isGpuBufferInstance(shardData)
+      && (!needsRowwise || layout === 'row')
+    );
+
+    if (canUseCpuReference && failOnCpuDequantPath) {
+      throw new Error(
+        `[LoaderDebug] CPU dequant path taken for ${name}; this run is configured fail-closed. ` +
+        'Set runtime.shared.debug.loader.forceGpuDequant=true to isolate GPU dequant.'
+      );
+    }
+
+    if (canUseCpuReference) {
+      const quantizedBytes = toUint8View(shardData);
+      const numBlocks = Math.ceil(location.size / Q4K_BLOCK_BYTES);
+      debugTrace.loader(
+        `Dequantizing ${name} with CPU reference path: ` +
+        `shape=[${location.shape.join(',')}], layout=${layout}, needsRowwise=${needsRowwise}`
+      );
+      const f32Weights = needsRowwise
+        ? dequantizeQ4KMRowWise(quantizedBytes, location.shape)
+        : dequantizeQ4KM(quantizedBytes, numBlocks, location.shape);
+      const outputBuffer = acquireAlignedBuffer(f32Weights.byteLength, `dequant_cpu_${name}`);
+      writeBufferAligned(device, outputBuffer, new Uint8Array(f32Weights.buffer));
+      releaseOwnedGpuBuffer(quantBuffer, ownsQuantBuffer);
+      ownsQuantBuffer = false;
+      return {
+        data: createWeightBuffer(outputBuffer, 'f32', layout, location.shape, name),
+        allocatedBuffers: [outputBuffer],
+      };
+    }
 
+    let numBlocks = null;
     let dequantizedTensor;
     if (needsRowwise) {
       const rows = location.shape[0];
@@ -213,7 +273,7 @@ export async function loadQ4KDequant(shardData, location, name, config) {
       );
       dequantizedTensor = await dequantizeRowwise(quantBuffer, rows, K, { outputDtype });
     } else {
-      const numBlocks = Math.ceil(location.size / Q4K_BLOCK_BYTES);
+      numBlocks = Math.ceil(location.size / Q4K_BLOCK_BYTES);
       debugTrace.loader(
         `Dequantizing ${name}: size=${location.size}, numBlocks=${numBlocks}, ` +
         `outputDtype=${outputDtype}, expectedOutput=${numBlocks * QK_K * (outputDtype === 'f16' ? 2 : 4)}`
@@ -223,10 +283,71 @@ export async function loadQ4KDequant(shardData, location, name, config) {
     dequantized = dequantizedTensor.buffer;
 
     debugTrace.loader(`Dequantized ${name}: resultSize=${dequantized.size}`);
+
+    if (runQ4KDequantParity && !isGpuBufferInstance(shardData) && dequantized && numBlocks !== null) {
+      const isProbeTarget = debugEnabled &&
+        (name.includes('.self_attn.q_proj.weight') || name.includes('.self_attn.k_proj.weight') ||
+          name.includes('.self_attn.v_proj.weight') || name.includes('.self_attn.qkv_proj.weight'));
+
+      if (isProbeTarget) {
+        try {
+          const bytesPerElem = outputDtype === 'f16' ? 2 : 4;
+          const requestedOutputBytes = numBlocks * QK_K * bytesPerElem;
+          const sampleCount = paritySamples;
+          const readSize = Math.min(sampleCount * bytesPerElem, dequantized.size);
+          const gpuRaw = await readBuffer(dequantized, readSize);
+          const gpuBytes = gpuRaw instanceof ArrayBuffer
+            ? new Uint8Array(gpuRaw)
+            : new Uint8Array(gpuRaw.buffer, gpuRaw.byteOffset, gpuRaw.byteLength);
+
+          let gpuVals;
+          if (outputDtype === 'f16') {
+            const u16 = new Uint16Array(gpuBytes.buffer, gpuBytes.byteOffset,
+              Math.min(sampleCount, Math.floor(gpuBytes.byteLength / 2)));
+            gpuVals = Array.from(u16, (half) => f16ToF32(half));
+          } else {
+            const f32 = new Float32Array(gpuBytes.buffer, gpuBytes.byteOffset,
+              Math.min(sampleCount, Math.floor(gpuBytes.byteLength / 4)));
+            gpuVals = Array.from(f32);
+          }
+
+          const quantizedBytes = toUint8View(shardData);
+          const cpuRef = Array.from(
+            needsRowwise
+              ? dequantizeQ4KMRowWise(quantizedBytes, location.shape)
+              : dequantizeQ4KM(quantizedBytes, numBlocks, location.shape)
+          ).slice(0, gpuVals.length);
+
+          let maxDiff = 0;
+          let diffIdx = -1;
+          for (let i = 0; i < gpuVals.length && i < cpuRef.length; i++) {
+            const d = Math.abs(gpuVals[i] - cpuRef[i]);
+            if (d > maxDiff) {
+              maxDiff = d;
+              diffIdx = i;
+            }
+          }
+
+          log.warn('DequantProbe',
+            `tensor="${name}" shape=[${location.shape}] ` +
+            `location.size=${location.size} numBlocks=${numBlocks} outputDtype=${outputDtype} ` +
+            `bytesPerElem=${bytesPerElem} requestedOutputBytes=${requestedOutputBytes} bufSize=${dequantized.size} ` +
+            `runParity=true sampleCount=${sampleCount}`
+          );
+          log.warn('DequantProbe',
+            `parity: maxDiff=${maxDiff.toFixed(8)} at idx=${diffIdx} ` +
+            `gpu[0..3]=[${gpuVals.slice(0, 4).map((v) => v.toFixed(6))}] ` +
+            `cpu[0..3]=[${cpuRef.slice(0, 4).map((v) => v.toFixed(6))}]`
+          );
+        } catch (e) {
+          log.warn('DequantProbe', `Readback failed: ${e.message}`);
+        }
+      }
+    }
+
     releaseOwnedGpuBuffer(quantBuffer, ownsQuantBuffer);
     ownsQuantBuffer = false;
 
-    const layout = getWeightLayout(location, config);
     const dtype = outputDtype;
 
     return {
@@ -309,8 +430,9 @@ export async function loadBF16(shardData, location, name, config) {
     const numElements = location.size / 2;
     const caps = config.gpuCapabilities || getKernelCapabilities();
     const isMatmulWeight = shouldDequantizeToF16(location);
+    const keepF32Weights = config.keepF32Weights === true;
 
-    if (caps?.hasF16 && isMatmulWeight) {
+    if (caps?.hasF16 && isMatmulWeight && !keepF32Weights) {
       const f16Tensor = await runBF16ToF16(srcBuffer, [numElements], name);
       resultBuffer = f16Tensor.buffer;
       releaseOwnedGpuBuffer(srcBuffer, ownsSrcBuffer);
@@ -327,6 +449,10 @@ export async function loadBF16(shardData, location, name, config) {
       };
     }
 
+    if (isMatmulWeight && keepF32Weights) {
+      debugTrace.loader(`Keeping BF16 matmul weight in f32: ${name} (keepF32Weights=true)`);
+    }
+
     const dstBuffer = await convertBF16ToF32GPU(srcBuffer, numElements, name);
     resultBuffer = dstBuffer;
     releaseOwnedGpuBuffer(srcBuffer, ownsSrcBuffer);

package/src/rules/inference/dtype.rules.json

@@ -59,6 +59,11 @@
     { "match": { "useF16": true }, "value": "f16" },
     { "match": {}, "value": { "context": "fallback" } }
   ],
+  "attentionProjectionOutputDtype": [
+    { "match": { "forceF32": true }, "value": "f32" },
+    { "match": { "useF16": true }, "value": "f16" },
+    { "match": {}, "value": { "context": "fallback" } }
+  ],
   "bytesPerElement": [
     { "match": { "dtype": "f16" }, "value": 2 },
     { "match": {}, "value": 4 }

package/src/rules/inference/kernel-path.rules.json

@@ -46,7 +46,7 @@
         "hasSubgroups": false,
         "kernelPathRef": "lfm2-q4k-dequant-f32a-online"
       },
-      "value": "gemma3-q4k-dequant-f32a-nosubgroups"
+      "value": "lfm2-q4k-dequant-f32a-nosubgroups"
     },
     {
       "match": {
@@ -77,7 +77,7 @@
     },
     {
       "match": { "kernelPathId": "lfm2-q4k-dequant-f32a-online" },
-      "value": "gemma3-q4k-dequant-f32a-nosubgroups"
+      "value": "lfm2-q4k-dequant-f32a-nosubgroups"
     },
     {
       "match": { "kernelPathId": "gemma2-f16-f16a" },

package/src/rules/kernels/moe.rules.mixtral.json

@@ -0,0 +1,75 @@
+{
+  "vendorQuirkProfile": [
+    {
+      "match": {
+        "vendor": {
+          "contains": ["intel", "amd"]
+        }
+      },
+      "value": {
+        "preferVec4Dequant": false,
+        "dequantTileShape": "scalar",
+        "routerWorkgroupSize": 128,
+        "maxTokensPerExpertScale": 0.85
+      }
+    },
+    {
+      "match": {
+        "vendor": {
+          "contains": ["nvidia", "apple", "qualcomm"]
+        }
+      },
+      "value": {
+        "preferVec4Dequant": false,
+        "dequantTileShape": "scalar",
+        "routerWorkgroupSize": 256,
+        "maxTokensPerExpertScale": 1.0
+      }
+    },
+    {
+      "match": {},
+      "value": {
+        "preferVec4Dequant": false,
+        "dequantTileShape": "scalar",
+        "routerWorkgroupSize": 128,
+        "maxTokensPerExpertScale": 1.0
+      }
+    }
+  ],
+  "routerTopKVariant": [
+    {
+      "match": { "modelType": "mixtral", "hasF16": true, "hasSubgroups": true, "routerDtype": "f32" },
+      "value": "softmax_topk_f32_subgroup"
+    },
+    {
+      "match": { "modelType": "mixtral", "routerDtype": "f32" },
+      "value": "softmax_topk_f32"
+    },
+    {
+      "match": { "modelType": "mixtral" },
+      "value": "softmax_topk_f32"
+    }
+  ],
+  "dequantVariant": [
+    {
+      "match": { "modelType": "mixtral", "weightsDtype": "q4k", "hasF16": true, "hasSubgroups": true, "outputDtype": "f32" },
+      "value": "q4k_expert_dequant_f32_subgroup"
+    },
+    {
+      "match": { "modelType": "mixtral", "weightsDtype": "q4k", "outputDtype": "f16", "hasF16": true },
+      "value": "q4k_expert_dequant_f16"
+    },
+    {
+      "match": { "modelType": "mixtral", "weightsDtype": "q4k" },
+      "value": "q4k_expert_dequant_f32"
+    },
+    {
+      "match": { "modelType": "mixtral", "weightsDtype": "f16", "outputDtype": "f16", "hasF16": true },
+      "value": "f16_expert_passthrough"
+    },
+    {
+      "match": { "modelType": "mixtral" },
+      "value": "f16_expert_upcast_f32"
+    }
+  ]
+}

package/src/rules/kernels/softmax.rules.json

@@ -16,6 +16,8 @@
       },
       "value": "gptoss_router_topk"
     },
+    { "match": { "modelType": "mixtral", "inputDtype": "f16", "weightsDtype": "f16" }, "value": "fused_f16_w16" },
+    { "match": { "modelType": "mixtral" }, "value": "fused" },
     { "match": { "inputDtype": "f16", "weightsDtype": "f16" }, "value": "fused_f16_w16" },
     { "match": { "inputDtype": "f16" }, "value": "fused_f16" },
     { "match": {}, "value": "fused" }

package/src/rules/kernels/split-qg.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "outputDtype": "f16" }, "value": "f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/rule-registry.d.ts

@@ -20,6 +20,7 @@ type KernelRuleGroup =
   | 'matmul'
   | 'moe'
   | 'moeGptoss'
+  | 'moeMixtral'
   | 'residual'
   | 'rmsnorm'
   | 'rope'

package/src/rules/rule-registry.js

@@ -38,6 +38,7 @@ const layernormRules = await loadJson('./kernels/layernorm.rules.json', import.m
 const matmulRules = await loadJson('./kernels/matmul.rules.json', import.meta.url, 'Failed to load rules');
 const kernelMoeRules = await loadJson('./kernels/moe.rules.json', import.meta.url, 'Failed to load rules');
 const kernelMoeGptOssRules = await loadJson('./kernels/moe.rules.gptoss.json', import.meta.url, 'Failed to load rules');
+const kernelMoeMixtralRules = await loadJson('./kernels/moe.rules.mixtral.json', import.meta.url, 'Failed to load rules');
 const modulateRules = await loadJson('./kernels/modulate.rules.json', import.meta.url, 'Failed to load rules');
 const pixelShuffleRules = await loadJson('./kernels/pixel_shuffle.rules.json', import.meta.url, 'Failed to load rules');
 const repeatChannelsRules = await loadJson('./kernels/repeat-channels.rules.json', import.meta.url, 'Failed to load rules');
@@ -50,6 +51,7 @@ const sampleRules = await loadJson('./kernels/sample.rules.json', import.meta.ur
 const scaleRules = await loadJson('./kernels/scale.rules.json', import.meta.url, 'Failed to load rules');
 const siluRules = await loadJson('./kernels/silu.rules.json', import.meta.url, 'Failed to load rules');
 const splitQkvRules = await loadJson('./kernels/split-qkv.rules.json', import.meta.url, 'Failed to load rules');
+const splitQgRules = await loadJson('./kernels/split-qg.rules.json', import.meta.url, 'Failed to load rules');
 const softmaxRules = await loadJson('./kernels/softmax.rules.json', import.meta.url, 'Failed to load rules');
 const upsample2dRules = await loadJson('./kernels/upsample2d.rules.json', import.meta.url, 'Failed to load rules');
 const configRules = await loadJson('./inference/config.rules.json', import.meta.url, 'Failed to load rules');
@@ -112,6 +114,7 @@ const RULE_SETS = {
     matmul: matmulRules,
     moe: kernelMoeRules,
     moeGptoss: kernelMoeGptOssRules,
+    moeMixtral: kernelMoeMixtralRules,
     modulate: modulateRules,
     pixel_shuffle: pixelShuffleRules,
     repeatChannels: repeatChannelsRules,
@@ -124,6 +127,7 @@ const RULE_SETS = {
     scale: scaleRules,
     silu: siluRules,
     splitQkv: splitQkvRules,
+    splitQg: splitQgRules,
     softmax: softmaxRules,
     upsample2d: upsample2dRules,
   },

package/src/storage/downloader.js

@@ -2,6 +2,7 @@
 
 import {
   parseManifest,
+  getExpectedShardHash,
   getManifestUrl,
 } from '../formats/rdrr/index.js';
 
@@ -726,7 +727,7 @@ export async function downloadModel(
         if (!algorithm) {
           throw new Error('Manifest missing hashAlgorithm for download verification.');
         }
-        const expectedHash = shardInfo.hash;
+        const expectedHash = getExpectedShardHash(shardInfo, algorithm);
         if (!expectedHash) {
           throw new Error(`Shard ${shardIndex} is missing hash in manifest`);
         }

package/src/storage/quickstart-downloader.d.ts

@@ -13,6 +13,7 @@
 
 import type { DownloadProgress } from './downloader.js';
 import type { PreflightResult, ModelRequirements } from './preflight.js';
+import type { HfResolveConfig } from '../utils/hf-resolve-url.js';
 
 /**
  * Remote model configuration
@@ -24,6 +25,8 @@ export interface RemoteModelConfig {
   displayName: string;
   /** Base URL for shards (any static CDN) */
   baseUrl?: string | null;
+  /** Hosted Hugging Face source used when baseUrl is omitted */
+  hf?: HfResolveConfig | null;
   /** Model requirements for pre-flight checks */
   requirements: ModelRequirements;
 }

package/src/storage/quickstart-downloader.js

@@ -7,6 +7,7 @@ import {
 } from './preflight.js';
 import { formatBytes } from './quota.js';
 import { getCdnBasePath } from './download-types.js';
+import { buildHfResolveBaseUrl, DEFAULT_HF_CDN_BASE_URL } from '../utils/hf-resolve-url.js';
 
 // ============================================================================
 // Model Registry
@@ -15,40 +16,14 @@ import { getCdnBasePath } from './download-types.js';
 
 let cdnBaseOverride = null;
 
-
-function getEffectiveCDNBaseUrl() {
-  const runtimeBase = getCdnBasePath();
-  const base = cdnBaseOverride ?? runtimeBase ?? '';
-  if (base) return base;
-
-  // Auto-detect: use same origin for Firebase Hosting or local dev
-  if (typeof globalThis.location !== 'undefined') {
-    const path = globalThis.location.pathname || '';
-    if (
-      path === '/d' ||
-      path.startsWith('/d/') ||
-      path === '/doppler' ||
-      path.startsWith('/doppler/') ||
-      path === '/dr' ||
-      path.startsWith('/dr/') ||
-      globalThis.location.host.includes('replo')
-    ) {
-      return `${globalThis.location.origin}/doppler/models`;
-    }
-    return `${globalThis.location.origin}/models`;
-  }
-  // Fallback for non-browser-global contexts
-  return '/models';
-}
-
-
 export function setCDNBaseUrl(url) {
-  cdnBaseOverride = url.replace(/\/$/, ''); // Remove trailing slash
+  const normalized = typeof url === 'string' ? url.trim().replace(/\/$/, '') : '';
+  cdnBaseOverride = normalized || null;
 }
 
 
 export function getCDNBaseUrl() {
-  return getEffectiveCDNBaseUrl();
+  return cdnBaseOverride ?? getCdnBasePath() ?? DEFAULT_HF_CDN_BASE_URL;
 }
 
 
@@ -57,12 +32,22 @@ export const QUICKSTART_MODELS = {
     modelId: 'gemma-3-270m-it-q4k-ehf16-af32',
     displayName: 'Gemma 3 270M IT (Q4K)',
     baseUrl: null,
+    hf: {
+      repoId: 'Clocksmith/rdrr',
+      revision: 'ca6f0dbdf3882d3893a65cf48f2bb6f1520df162',
+      path: 'models/gemma-3-270m-it-q4k-ehf16-af32',
+    },
     requirements: MODEL_REQUIREMENTS['gemma-3-270m-it-q4k-ehf16-af32'],
   },
   'google-embeddinggemma-300m-q4k-ehf16-af32': {
     modelId: 'google-embeddinggemma-300m-q4k-ehf16-af32',
     displayName: 'EmbeddingGemma 300M (Q4K)',
     baseUrl: null,
+    hf: {
+      repoId: 'Clocksmith/rdrr',
+      revision: '7e79c466d54455bd370c81685956ea9abae0fd30',
+      path: 'models/google-embeddinggemma-300m-q4k-ehf16-af32',
+    },
     requirements: MODEL_REQUIREMENTS['google-embeddinggemma-300m-q4k-ehf16-af32'],
   },
 };
@@ -82,6 +67,18 @@ export function registerQuickStartModel(config) {
   QUICKSTART_MODELS[config.modelId] = config;
 }
 
+function resolveQuickStartModelBaseUrl(config) {
+  if (typeof config?.baseUrl === 'string' && config.baseUrl.trim().length > 0) {
+    return config.baseUrl.trim().replace(/\/$/, '');
+  }
+  if (config?.hf) {
+    return buildHfResolveBaseUrl(config.hf, { cdnBasePath: getCDNBaseUrl() });
+  }
+  throw new Error(
+    `Quickstart model "${config?.modelId ?? 'unknown'}" is missing an explicit baseUrl or hosted Hugging Face source.`
+  );
+}
+
 // ============================================================================
 // Download Functions
 // ============================================================================
@@ -190,7 +187,7 @@ export async function downloadQuickStartModel(
       signal,
     };
 
-    const baseUrl = config.baseUrl ?? `${getEffectiveCDNBaseUrl()}/${config.modelId}`;
+    const baseUrl = resolveQuickStartModelBaseUrl(config);
     const success = await downloadModel(
       baseUrl,
       onProgress,

package/src/storage/shard-manager.js

@@ -1,5 +1,6 @@
 import {
   getManifest,
+  getExpectedShardHash,
   getShardInfo,
   getShardCount,
   generateShardFilename,
@@ -280,7 +281,7 @@ export async function writeShard(shardIndex, data, options = { verify: true }) {
       const manifest = getManifest();
       const algorithm = requireManifestHashAlgorithm(manifest, 'shard write');
       const hash = await computeHash(bytes, algorithm);
-      const expectedHash = shardInfo.hash;
+      const expectedHash = getExpectedShardHash(shardInfo, algorithm);
       if (!expectedHash) {
         await backend.deleteFile(shardInfo.filename);
         throw new Error(`Shard ${shardIndex} is missing hash in manifest`);
@@ -369,7 +370,7 @@ export async function loadShard(shardIndex, options = { verify: false }) {
       const manifest = getManifest();
       const algorithm = requireManifestHashAlgorithm(manifest, 'shard load');
       const hash = await computeHash(buffer, algorithm);
-      const expectedHash = shardInfo.hash;
+      const expectedHash = getExpectedShardHash(shardInfo, algorithm);
       if (!expectedHash) {
         throw new Error(`Shard ${shardIndex} is missing hash in manifest`);
       }
@@ -531,7 +532,7 @@ export async function verifyIntegrity(options = {}) {
         const buffer = await loadShard(i, { verify: false });
         const hash = await computeHash(buffer, algorithm);
         const shardInfo = getShardInfo(i);
-        const expectedHash = shardInfo?.hash;
+        const expectedHash = getExpectedShardHash(shardInfo, algorithm);
         if (!expectedHash) {
           corruptShards.push(i);
           continue;

package/src/tooling/conversion-config-materializer.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 
 import { createConverterConfig } from '../config/schema/index.js';
 import { resolveConversionPlan } from '../converter/conversion-plan.js';
+import { normalizeQuantTag } from '../converter/quantization-info.js';
 
 function toSafeString(value) {
   if (typeof value !== 'string') return '';
@@ -10,10 +11,7 @@ function toSafeString(value) {
 }
 
 function normalizeQuantizationTag(value) {
-  const raw = toSafeString(value).toUpperCase();
-  if (!raw) return 'f16';
-  if (raw === 'Q4_K_M' || raw === 'Q4_K') return 'q4k';
-  return raw.toLowerCase();
+  return normalizeQuantTag(toSafeString(value));
 }
 
 function resolveArchitectureHint(architecture) {
@@ -37,7 +35,7 @@ function extractSourceQuantization(manifest) {
   if (explicitWeights) return explicitWeights;
   const explicitQuant = toSafeString(manifest?.quantization);
   if (explicitQuant) return explicitQuant;
-  return 'f16';
+  return normalizeQuantTag(null);
 }
 
 function buildRefreshRawConfig(manifest) {

package/src/tooling/node-converter.js

@@ -541,18 +541,24 @@ async function listRelativeFiles(rootDir, relDir = '', out = []) {
   return out;
 }
 
-async function clearExistingShardFiles(outputDir) {
+async function clearExistingConversionOutputs(outputDir) {
   let entries;
   try {
     entries = await fs.readdir(outputDir, { withFileTypes: true });
   } catch {
     return;
   }
-  const shardFiles = entries
-    .filter((entry) => entry.isFile() && /^shard_\d{5}\.bin$/i.test(entry.name))
+  const artifactFiles = entries
+    .filter((entry) => (
+      entry.isFile()
+      && (
+        /^shard_\d{5}\.bin$/i.test(entry.name)
+        || entry.name === 'manifest.json'
+      )
+    ))
     .map((entry) => path.join(outputDir, entry.name));
-  if (shardFiles.length === 0) return;
-  await Promise.all(shardFiles.map((filePath) => fs.unlink(filePath)));
+  if (artifactFiles.length === 0) return;
+  await Promise.all(artifactFiles.map((filePath) => fs.unlink(filePath)));
 }
 
 function createNodeConvertIO(outputDir, options) {
@@ -875,6 +881,7 @@ export async function convertSafetensorsDirectory(options) {
   let sourceQuantization = null;
   let tokenizerJson = null;
   let tokenizerConfig = null;
+  let generationConfig = null;
   let hasTokenizerModel = false;
   let tokenizerModelPath = null;
   let diffusionAuxFiles = [];
@@ -1101,6 +1108,7 @@ export async function convertSafetensorsDirectory(options) {
       },
     });
     config = parsedTransformer.config;
+    generationConfig = parsedTransformer.generationConfig ?? null;
     tensors = parsedTransformer.tensors;
     architectureHint = parsedTransformer.architectureHint;
     architecture = extractArchitecture(config, null);
@@ -1151,7 +1159,7 @@ export async function convertSafetensorsDirectory(options) {
   const outputDir = resolveOutputDir(outputDirOverride, converterConfig, modelId);
 
   await fs.mkdir(outputDir, { recursive: true });
-  await clearExistingShardFiles(outputDir);
+  await clearExistingConversionOutputs(outputDir);
 
   const model = {
     name: path.basename(inputDir),
@@ -1169,6 +1177,7 @@ export async function convertSafetensorsDirectory(options) {
     quantization: targetQuantization,
     tokenizerJson,
     tokenizerConfig,
+    generationConfig,
     tokenizerModel: hasTokenizerModel ? 'tokenizer.model' : null,
   };
 
@@ -1177,6 +1186,15 @@ export async function convertSafetensorsDirectory(options) {
     computeHash,
     readRange: fileRangeReader.readRange,
   });
+  const deferredManifestState = {
+    manifest: null,
+  };
+  const convertIo = {
+    ...io,
+    async writeManifest(manifest) {
+      deferredManifestState.manifest = manifest;
+    },
+  };
   const manifestArchitecture = modelKind === 'diffusion' ? 'diffusion' : architecture;
   let workerPool = null;
   let workerTensorTransformer = null;
@@ -1241,7 +1259,7 @@ export async function convertSafetensorsDirectory(options) {
     }));
 
     const convertTimer = createStageTimer('Convert tensors');
-    result = await convertModel(model, io, {
+    result = await convertModel(model, convertIo, {
       modelId,
       modelType: resolvedModelType,
       quantization: targetQuantization,
@@ -1279,6 +1297,9 @@ export async function convertSafetensorsDirectory(options) {
   }
 
   normalizeTokenizerManifest(result.manifest);
+  if (!deferredManifestState.manifest) {
+    throw new Error('node convert: convert core did not produce a manifest.');
+  }
   await io.writeManifest(result.manifest);
 
   const report = buildConvertReport(result, {