@simulatte/doppler 0.1.8 → 0.1.9

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/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');
@@ -113,6 +114,7 @@ const RULE_SETS = {
     matmul: matmulRules,
     moe: kernelMoeRules,
     moeGptoss: kernelMoeGptOssRules,
+    moeMixtral: kernelMoeMixtralRules,
     modulate: modulateRules,
     pixel_shuffle: pixelShuffleRules,
     repeatChannels: repeatChannelsRules,

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/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) {
@@ -1153,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),
@@ -1180,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;
@@ -1244,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,
@@ -1282,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, {

package/src/tooling/node-source-runtime.js

@@ -1,4 +1,6 @@
+import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import {
   HEADER_READ_SIZE,
@@ -16,7 +18,6 @@ import { parseTransformerModel } from '../converter/parsers/transformer.js';
 import { parseGGUFHeader } from '../formats/gguf/types.js';
 import { parseSafetensorsHeader } from '../formats/safetensors/types.js';
 import { log } from '../debug/index.js';
-import { computeHash } from '../storage/shard-manager.js';
 import {
   buildSourceRuntimeBundle,
   createSourceStorageContext,
@@ -137,7 +138,12 @@ async function readRange(filePath, offset, length) {
       return new ArrayBuffer(0);
     }
     const out = Buffer.allocUnsafe(end - start);
-    await handle.read(out, 0, out.length, start);
+    let pos = 0;
+    while (pos < out.length) {
+      const { bytesRead } = await handle.read(out, pos, out.length - pos, start + pos);
+      if (bytesRead === 0) break;
+      pos += bytesRead;
+    }
     return out.buffer.slice(out.byteOffset, out.byteOffset + out.byteLength);
   } finally {
     await handle.close();
@@ -449,18 +455,36 @@ async function addHashesToFileEntries(entries, hashAlgorithm) {
   for (const entry of Array.isArray(entries) ? entries : []) {
     const filePath = normalizePath(entry?.path);
     if (!filePath) continue;
-    const bytes = await readFileBytes(filePath, `source asset (${filePath})`);
+    const stats = await getPathStats(filePath, `source asset (${filePath})`);
     normalized.push({
       ...entry,
       path: filePath,
-      size: Number.isFinite(entry?.size) ? Math.max(0, Math.floor(Number(entry.size))) : bytes.byteLength,
-      hash: await computeHash(new Uint8Array(bytes), hashAlgorithm),
+      size: Number.isFinite(entry?.size) ? Math.max(0, Math.floor(Number(entry.size))) : Number(stats.size),
+      hash: await computeFileHash(filePath, hashAlgorithm),
       hashAlgorithm,
     });
   }
   return normalized;
 }
 
+async function computeFileHash(filePath, hashAlgorithm) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash(hashAlgorithm);
+    const stream = createReadStream(filePath);
+
+    stream.on('data', (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on('end', () => {
+      resolve(hash.digest('hex'));
+    });
+    stream.on('error', (error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      reject(new Error(`Failed to stream source asset "${filePath}" for hashing: ${message}`));
+    });
+  });
+}
+
 export async function resolveNodeSourceRuntimeBundle(options = {}) {
   const inputPath = normalizePath(options.inputPath);
   if (!inputPath) {

package/src/tooling/node-webgpu.js

@@ -51,7 +51,7 @@ function resolveCandidateModuleSpecifier(candidate) {
 }
 
 function resolveDefaultWebgpuModuleSpecifiers() {
-  return ['@simulatte/webgpu', 'webgpu'];
+  return ['webgpu', '@simulatte/webgpu'];
 }
 
 function resolveExplicitWebgpuModuleSpecifier() {
@@ -189,18 +189,35 @@ function resolveGpuFromModule(mod) {
     return fromModule;
   }
 
-  const factory = mod.create || mod.default?.create;
-  if (typeof factory === 'function') {
-    let created = null;
+  const tryCreateFactory = (factory) => {
+    if (typeof factory !== 'function') {
+      return null;
+    }
     try {
-      created = factory([]);
+      return factory([]);
     } catch {
       try {
-        created = factory();
+        return factory();
       } catch {
-        created = null;
+        return null;
       }
     }
+  };
+
+  const instanceFactory = mod.createInstance || mod.default?.createInstance;
+  const createdFromInstanceFactory = tryCreateFactory(instanceFactory);
+  if (createdFromInstanceFactory) {
+    if (typeof createdFromInstanceFactory.requestAdapter === 'function') {
+      return createdFromInstanceFactory;
+    }
+    if (createdFromInstanceFactory.gpu && typeof createdFromInstanceFactory.gpu.requestAdapter === 'function') {
+      return createdFromInstanceFactory.gpu;
+    }
+  }
+
+  const factory = mod.create || mod.default?.create;
+  if (typeof factory === 'function') {
+    const created = tryCreateFactory(factory);
     if (created) {
       if (typeof created.requestAdapter === 'function') {
         return created;

package/src/utils/hf-resolve-url.d.ts

@@ -0,0 +1,16 @@
+export interface HfResolveConfig {
+  repoId: string;
+  revision?: string | null;
+  path: string;
+}
+
+export interface HfResolveUrlOptions {
+  cdnBasePath?: string;
+}
+
+export declare const DEFAULT_HF_CDN_BASE_URL: string;
+
+export declare function buildHfResolveBaseUrl(
+  hfConfig: HfResolveConfig | null | undefined,
+  options?: HfResolveUrlOptions
+): string;

package/src/utils/hf-resolve-url.js

@@ -0,0 +1,17 @@
+export const DEFAULT_HF_CDN_BASE_URL = 'https://huggingface.co';
+
+export function buildHfResolveBaseUrl(hfConfig, options = {}) {
+  const repoId = typeof hfConfig?.repoId === 'string' ? hfConfig.repoId.trim() : '';
+  const repoPath = typeof hfConfig?.path === 'string' ? hfConfig.path.trim().replace(/^\/+/, '') : '';
+  if (!repoId || !repoPath) {
+    throw new Error('Hosted Hugging Face source requires repoId and path.');
+  }
+
+  const revision = typeof hfConfig?.revision === 'string' && hfConfig.revision.trim().length > 0
+    ? hfConfig.revision.trim()
+    : 'main';
+  const cdnBasePath = typeof options?.cdnBasePath === 'string' && options.cdnBasePath.trim().length > 0
+    ? options.cdnBasePath.trim()
+    : DEFAULT_HF_CDN_BASE_URL;
+  return `${cdnBasePath.replace(/\/$/, '')}/${repoId}/resolve/${revision}/${repoPath}`;
+}

package/src/version.js

@@ -1,2 +1,2 @@
-export const DOPPLER_VERSION = '0.1.7';
+export const DOPPLER_VERSION = '0.1.9';
 export const DOPPLER_PROVIDER_VERSION = DOPPLER_VERSION;

package/src/tooling/node-convert.d.ts

@@ -1,54 +0,0 @@
-import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
-import type { ExecutionContractArtifact } from '../config/execution-contract-check.js';
-import type { ExecutionV0GraphContractArtifact } from '../config/execution-v0-graph-contract-check.js';
-import type { ManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
-import type { SavedReportInfo } from '../storage/reports.js';
-
-export interface NodeConvertProgress {
-  stage: string | null;
-  current: number | null;
-  total: number | null;
-  message: string | null;
-  tensorName?: string | null;
-  tensorBytesCurrent?: number | null;
-  tensorBytesTotal?: number | null;
-}
-
-export interface NodeConvertExecutionConfig {
-  workers?: number | null;
-  workerCountPolicy?: 'cap' | 'error' | null;
-  maxInFlightJobs?: number | null;
-  rowChunkRows?: number | null;
-  rowChunkMinTensorBytes?: number | null;
-  useGpuCast?: boolean | null;
-  gpuCastMinTensorBytes?: number | null;
-}
-
-export interface ConvertSafetensorsDirectoryOptions {
-  /** Directory with safetensors/diffusion assets, or a direct .gguf file path. */
-  inputDir: string;
-  outputDir?: string | null;
-  modelId?: string | null;
-  converterConfig?: Partial<ConverterConfigSchema> | null;
-  execution?: NodeConvertExecutionConfig | null;
-  onProgress?: (progress: NodeConvertProgress) => void;
-}
-
-export interface ConvertSafetensorsDirectoryResult {
-  manifest: Record<string, unknown>;
-  shardCount: number;
-  tensorCount: number;
-  executionContractArtifact: ExecutionContractArtifact | null;
-  executionV0GraphContractArtifact: ExecutionV0GraphContractArtifact | null;
-  layerPatternContractArtifact: Record<string, unknown> | null;
-  requiredInferenceFieldsArtifact: ManifestRequiredInferenceFieldsArtifact | null;
-  report: Record<string, unknown>;
-  reportInfo: SavedReportInfo;
-  presetId: string;
-  modelType: string;
-  outputDir: string;
-}
-
-export declare function convertSafetensorsDirectory(
-  options: ConvertSafetensorsDirectoryOptions
-): Promise<ConvertSafetensorsDirectoryResult>;