@simulatte/doppler 0.1.7 → 0.1.9

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();
@@ -411,23 +417,74 @@ function buildNodeFileReaders() {
   };
 }
 
+// Source dtype → compute precision mapping for source-runtime inference.
+// BF16/F32 sources require f32 compute (BF16 has no native WebGPU support).
+// Quantized formats require f32 compute for dequantization accuracy.
+// F16 sources can use f16 compute directly.
+const SOURCE_QUANT_COMPUTE_MAP = {
+  'F16': 'f16',
+  'BF16': 'f32',
+  'F32': 'f32',
+  'Q4_K': 'f32',
+  'Q4_K_M': 'f32',
+  'Q6_K': 'f32',
+};
+const SOURCE_COMPUTE_DEFAULT = 'f16';
+
+function resolveSourceRuntimeComputePrecision(tensors, sourceQuantization) {
+  const dtypes = new Set();
+  for (const tensor of Array.isArray(tensors) ? tensors : []) {
+    const dtype = String(tensor?.dtype || '').trim().toUpperCase();
+    if (dtype) {
+      dtypes.add(dtype);
+    }
+  }
+  // If any tensor requires f32 compute, use f32 for all.
+  for (const dtype of dtypes) {
+    if (SOURCE_QUANT_COMPUTE_MAP[dtype] === 'f32') {
+      return 'f32';
+    }
+  }
+
+  const normalized = String(sourceQuantization || '').trim().toUpperCase();
+  return SOURCE_QUANT_COMPUTE_MAP[normalized] ?? SOURCE_COMPUTE_DEFAULT;
+}
+
 async function addHashesToFileEntries(entries, hashAlgorithm) {
   const normalized = [];
   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) {
@@ -473,6 +530,9 @@ export async function resolveNodeSourceRuntimeBundle(options = {}) {
   assertSupportedSourceDtypes(parsed.tensors, parsed.sourceKind);
 
   const converterConfig = createConverterConfig({
+    quantization: {
+      computePrecision: resolveSourceRuntimeComputePrecision(parsed.tensors, parsed.sourceQuantization),
+    },
     output: {
       modelBaseId: options.modelId || null,
     },

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/types/model.d.ts

@@ -9,7 +9,11 @@ export type ModelArchitecture =
   | 'gemma'
   | 'gemma2'
   | 'gemma3'
+  | 'embeddinggemma'
   | 'functiongemma'
+  | 'janus_text'
+  | 'lfm2'
+  | 'modernbert'
   | 'qwen2'
   | 'qwen3'
   | 'phi3'
@@ -19,6 +23,7 @@ export type ModelArchitecture =
   | 'deepseek'
   | 'mamba'
   | 'kimi_k2'
+  | 'translategemma'
   | 'transformer';
 
 /** Attention type variants */

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/tools/doppler-cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { existsSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -13,7 +14,8 @@ import { createToolingErrorEnvelope } from '../src/tooling/command-envelope.js';
 
 const NODE_WEBGPU_INCOMPLETE_MESSAGE = 'node command: WebGPU runtime is incomplete in Node';
 const CLI_POLICY_PATH = fileURLToPath(new URL('./configs/cli/doppler-cli-policy.json', import.meta.url));
-const DEFAULT_EXTERNAL_MODELS_ROOT = process.env.DOPPLER_EXTERNAL_MODELS_ROOT || '/media/x/models';
+const DEFAULT_EXTERNAL_MODELS_ROOT = process.env.DOPPLER_EXTERNAL_MODELS_ROOT
+  || (existsSync('/Volumes/models') ? '/Volumes/models' : '/media/x/models');
 const DEFAULT_EXTERNAL_RDRR_ROOT = path.join(DEFAULT_EXTERNAL_MODELS_ROOT, 'rdrr');
 const DEFAULT_CLI_POLICY = {
   defaults: {
@@ -1260,6 +1262,9 @@ function printMetricsSummary(result) {
       `prefill=${formatNumber(metrics.prefillTokensPerSec)} ` +
       `decode=${formatNumber(metrics.decodeTokensPerSec)}`
     );
+    if (typeof result.output === 'string' && result.output.length > 0) {
+      console.log(`[output] ${quoteOneLine(result.output)}`);
+    }
     printExecutionContractSummary(result);
     printExecutionV0GraphSummary(metrics.executionV0GraphContractArtifact);
     return;

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