@simulatte/doppler 0.1.6 → 0.1.7

package/src/browser/tensor-source-download.js

@@ -229,9 +229,15 @@ export async function createRemoteTensorSource(url, options = {}) {
   try {
     const source = await createHttpTensorSource(url, options);
     return { source, size: source.size, supportsRange: true };
-  } catch (_error) {
+  } catch (error) {
     if (options.allowDownloadFallback === false) {
-      throw _error;
+      throw error;
+    }
+    if (options.allowDownloadFallback !== true) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `HTTP tensor source failed for "${url}" and download fallback is not explicitly enabled: ${message}`
+      );
     }
     const downloaded = await createDownloadTensorSource(url, options);
     return { ...downloaded, supportsRange: false };

package/src/browser/tensor-source-http.d.ts

@@ -13,6 +13,7 @@ export interface HttpRangeProbe {
   size: number | null;
   acceptRanges: string | null;
   contentEncoding: string | null;
+  error?: string | null;
 }
 
 export interface HttpTensorSourceOptions {

package/src/browser/tensor-source-http.js

@@ -61,7 +61,7 @@ export async function probeHttpRange(url, options = {}) {
       acceptRanges,
       contentEncoding,
     };
-  } catch (_error) {
+  } catch (error) {
     return {
       ok: false,
       status: 0,
@@ -69,6 +69,7 @@ export async function probeHttpRange(url, options = {}) {
       size: null,
       acceptRanges: null,
       contentEncoding: null,
+      error: error instanceof Error ? error.message : String(error),
     };
   }
 }
@@ -76,6 +77,9 @@ export async function probeHttpRange(url, options = {}) {
 export async function createHttpTensorSource(url, options = {}) {
   const { headers, signal, name: overrideName } = options;
   const probe = await probeHttpRange(url, { headers, signal });
+  if (!probe.ok && probe.status === 0 && probe.error) {
+    throw new Error(`HTTP tensor source probe failed for "${url}": ${probe.error}`);
+  }
   if (!probe.supportsRange || probe.size == null) {
     throw new Error('HTTP range requests not supported for tensor source');
   }

package/src/client/doppler-api.browser.js

@@ -227,9 +227,7 @@ async function* dopplerGenerate(prompt, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler() requires options.model.');
   }
-  if (options.runtimeConfig !== undefined || options.runtimePreset !== undefined) {
-    throw new Error('doppler() does not accept load-affecting options. Use doppler.load(model, options) instead.');
-  }
+  assertNoLoadAffectingOptions('doppler()', options);
   const model = await getCachedModel(options.model, { onProgress: options.onProgress });
   yield* model.generate(prompt, options);
 }
@@ -240,10 +238,26 @@ export function doppler(prompt, options) {
 
 doppler.load = load;
 
+function assertNoLoadAffectingOptions(apiName, options) {
+  if (!options || typeof options !== 'object') {
+    return;
+  }
+  if (
+    options.runtimeConfig !== undefined
+    || options.runtimePreset !== undefined
+    || options.runtimeConfigUrl !== undefined
+  ) {
+    throw new Error(
+      `${apiName} does not accept load-affecting options. Use doppler.load(model, options) instead.`
+    );
+  }
+}
+
 doppler.text = async function text(prompt, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler.text() requires options.model.');
   }
+  assertNoLoadAffectingOptions('doppler.text()', options);
   const model = await getCachedModel(options.model, { onProgress: options.onProgress });
   return model.generateText(prompt, options);
 };
@@ -252,6 +266,7 @@ doppler.chat = function chat(messages, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler.chat() requires options.model.');
   }
+  assertNoLoadAffectingOptions('doppler.chat()', options);
   return (async function* run() {
     const model = await getCachedModel(options.model, { onProgress: options.onProgress });
     yield* model.chat(messages, options);
@@ -262,6 +277,7 @@ doppler.chatText = async function chatText(messages, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler.chatText() requires options.model.');
   }
+  assertNoLoadAffectingOptions('doppler.chatText()', options);
   const model = await getCachedModel(options.model, { onProgress: options.onProgress });
   return model.chatText(messages, options);
 };
@@ -284,5 +300,5 @@ doppler.evictAll = async function evictAll() {
 
 doppler.listModels = async function listModels() {
   const models = await listQuickstartModels();
-  return models.map((entry) => entry.aliases[0] || entry.modelId);
+  return models.map((entry) => entry.modelId);
 };

package/src/client/doppler-api.js

@@ -128,6 +128,21 @@ async function collectText(iterable) {
   return output;
 }
 
+function assertNoLoadAffectingOptions(apiName, options) {
+  if (!options || typeof options !== 'object') {
+    return;
+  }
+  if (
+    options.runtimeConfig !== undefined
+    || options.runtimePreset !== undefined
+    || options.runtimeConfigUrl !== undefined
+  ) {
+    throw new Error(
+      `${apiName} does not accept load-affecting options. Use doppler.load(model, options) instead.`
+    );
+  }
+}
+
 function createModelHandle(pipeline, resolved) {
   return {
     generate(prompt, options = {}) {
@@ -246,9 +261,7 @@ async function* dopplerGenerate(prompt, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler() requires options.model.');
   }
-  if (options.runtimeConfig !== undefined || options.runtimePreset !== undefined) {
-    throw new Error('doppler() does not accept load-affecting options. Use doppler.load(model, options) instead.');
-  }
+  assertNoLoadAffectingOptions('doppler()', options);
   const model = await getCachedModel(options.model, { onProgress: options.onProgress });
   yield* model.generate(prompt, options);
 }
@@ -259,12 +272,14 @@ export function doppler(prompt, options) {
 
 doppler.load = load;
 doppler.text = async function text(prompt, options) {
+  assertNoLoadAffectingOptions('doppler.text()', options);
   return collectText(doppler(prompt, options));
 };
 doppler.chat = function chat(messages, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler.chat() requires options.model.');
   }
+  assertNoLoadAffectingOptions('doppler.chat()', options);
   return (async function* () {
     const model = await getCachedModel(options.model, { onProgress: options.onProgress });
     yield* model.chat(messages, options);
@@ -274,6 +289,7 @@ doppler.chatText = async function chatText(messages, options = {}) {
   if (!options || typeof options !== 'object' || options.model == null) {
     throw new Error('doppler.chatText() requires options.model.');
   }
+  assertNoLoadAffectingOptions('doppler.chatText()', options);
   const model = await getCachedModel(options.model, { onProgress: options.onProgress });
   return model.chatText(messages, options);
 };

package/src/client/doppler-provider/generation.js

@@ -11,6 +11,15 @@ import { getPipeline } from './model-manager.js';
 
 export { formatGemmaChat, formatLlama3Chat, formatGptOssChat };
 
+function assertSupportedGenerateOptions(options = {}) {
+  if (Array.isArray(options?.stopTokens) && options.stopTokens.length > 0) {
+    throw new Error(
+      'Doppler provider generate options do not support stopTokens on this surface. ' +
+      'Use stopSequences instead.'
+    );
+  }
+}
+
 function resolveChatTemplate(pipeline, options) {
   const override = options?.useChatTemplate;
   const runtimeEnabled = pipeline?.runtimeConfig?.inference?.chatTemplate?.enabled;
@@ -21,6 +30,7 @@ function resolveChatTemplate(pipeline, options) {
 }
 
 export async function* generate(prompt, options = {}) {
+  assertSupportedGenerateOptions(options);
   const pipeline = getPipeline();
   if (!pipeline) {
     throw new Error('No model loaded. Call loadModel() first.');
@@ -52,6 +62,7 @@ export async function* generate(prompt, options = {}) {
 }
 
 export async function prefillKV(prompt, options = {}) {
+  assertSupportedGenerateOptions(options);
   const pipeline = getPipeline();
   if (!pipeline) {
     throw new Error('No model loaded. Call loadModel() first.');
@@ -61,6 +72,7 @@ export async function prefillKV(prompt, options = {}) {
 }
 
 export async function* generateWithPrefixKV(prefix, prompt, options = {}) {
+  assertSupportedGenerateOptions(options);
   const pipeline = getPipeline();
   if (!pipeline) {
     throw new Error('No model loaded. Call loadModel() first.');

package/src/client/doppler-provider/model-manager.d.ts

@@ -10,6 +10,16 @@ export declare function getPipeline(): InferencePipeline | null;
 
 export declare function getCurrentModelId(): string | null;
 
+export declare function verifyExplicitModelUrlMatch(
+  localManifest: RDRRManifest | Record<string, unknown> | null | undefined,
+  modelUrl: string | null | undefined,
+  fetchRemoteManifest?: (modelUrl: string) => Promise<RDRRManifest | Record<string, unknown> | null>
+): Promise<void>;
+
+export declare function shouldAutoTuneKernels(
+  runtimeConfig?: Record<string, unknown> | null
+): boolean;
+
 export declare function extractTextModelConfig(manifest: RDRRManifest): TextModelConfig;
 
 export declare function readOPFSFile(path: string): Promise<ArrayBuffer>;

package/src/client/doppler-provider/model-manager.js

@@ -20,6 +20,12 @@ import { log } from '../../debug/index.js';
 import { DopplerCapabilities } from './types.js';
 import { GB, HEADER_READ_SIZE } from '../../config/schema/index.js';
 import { resolveBridgeSourceRuntimeBundle } from './source-runtime.js';
+import { getRuntimeConfig } from '../../config/runtime.js';
+import {
+  buildSourceArtifactFingerprint,
+  createStoredSourceArtifactContext,
+  verifyStoredSourceArtifact,
+} from '../../storage/source-artifact-store.js';
 
 let pipeline = null;
 let currentModelId = null;
@@ -34,6 +40,9 @@ function manifestsDiffer(localManifest, remoteManifest) {
   const localShards = Array.isArray(localManifest.shards) ? localManifest.shards : [];
   const remoteShards = Array.isArray(remoteManifest.shards) ? remoteManifest.shards : [];
   if (localShards.length !== remoteShards.length) return true;
+  if (buildSourceArtifactFingerprint(localManifest) !== buildSourceArtifactFingerprint(remoteManifest)) {
+    return true;
+  }
 
   for (let i = 0; i < localShards.length; i++) {
     const local = localShards[i];
@@ -61,6 +70,34 @@ async function tryFetchRemoteManifest(modelUrl) {
   return manifest;
 }
 
+export async function verifyExplicitModelUrlMatch(
+  localManifest,
+  modelUrl,
+  fetchRemoteManifest = tryFetchRemoteManifest
+) {
+  if (!localManifest || !modelUrl) {
+    return;
+  }
+  let remoteManifest = null;
+  try {
+    remoteManifest = await fetchRemoteManifest(modelUrl);
+  } catch (error) {
+    throw new Error(
+      `Could not compare cached manifest with explicit modelUrl "${modelUrl}": ${error.message}`
+    );
+  }
+  if (remoteManifest && manifestsDiffer(localManifest, remoteManifest)) {
+    throw new Error(
+      `Explicit modelUrl "${modelUrl}" does not match the cached manifest for "${localManifest.modelId ?? 'unknown'}". ` +
+      'Clear the cache or load the matching source explicitly.'
+    );
+  }
+}
+
+export function shouldAutoTuneKernels(runtimeConfig = getRuntimeConfig()) {
+  return runtimeConfig?.shared?.kernelWarmup?.autoTune === true;
+}
+
 export function getPipeline() {
   return pipeline;
 }
@@ -69,6 +106,14 @@ export function getCurrentModelId() {
   return currentModelId;
 }
 
+function requireManifestQuantization(manifest) {
+  const quantization = String(manifest?.quantization ?? '').trim();
+  if (!quantization) {
+    throw new Error('Manifest is missing quantization; re-convert the model.');
+  }
+  return quantization.toUpperCase();
+}
+
 export function extractTextModelConfig(manifest) {
   const arch = (manifest.architecture && typeof manifest.architecture === 'object')
     ? manifest.architecture
@@ -86,12 +131,12 @@ export function extractTextModelConfig(manifest) {
     headDim: arch.headDim,
     vocabSize: arch.vocabSize,
     maxSeqLen: arch.maxSeqLen,
-    quantization: (manifest?.quantization || 'f16').toUpperCase(),
+    quantization: requireManifestQuantization(manifest),
   };
 }
 
 function estimateDequantizedWeightsBytes(manifest) {
-  const q = (manifest?.quantization || '').toUpperCase();
+  const q = requireManifestQuantization(manifest);
   const total = manifest?.totalSize || 0;
   if (q.startsWith('Q4')) {
     return total * 8;
@@ -243,6 +288,24 @@ export async function loadModel(modelId, modelUrl = null, onProgress = null, loc
           manifest = parseManifest(manifestJson);
           log.info('DopplerProvider', `Loaded manifest via bridge: ${manifest.modelId}`);
           if (onProgress) onProgress({ stage: 'manifest', message: 'Manifest loaded via bridge' });
+          const persistedSourceBundle = await resolveBridgeSourceRuntimeBundle({
+            bridgeClient,
+            localPath,
+            modelId,
+            manifest,
+            verifyHashes: true,
+            onProgress: (progress) => onProgress?.(progress),
+          });
+          if (persistedSourceBundle) {
+            bridgeStorageContext = persistedSourceBundle.storageContext;
+            bridgeSourceMode = true;
+            if (onProgress) {
+              onProgress({
+                stage: 'manifest',
+                message: `Direct-source manifest ready (${persistedSourceBundle.sourceKind} artifact mode)`,
+              });
+            }
+          }
         } catch (manifestError) {
           log.warn(
             'DopplerProvider',
@@ -252,6 +315,7 @@ export async function loadModel(modelId, modelUrl = null, onProgress = null, loc
             bridgeClient,
             localPath,
             modelId,
+            verifyHashes: true,
             onProgress: (progress) => onProgress?.(progress),
           });
           if (!sourceBundle) {
@@ -286,25 +350,26 @@ export async function loadModel(modelId, modelUrl = null, onProgress = null, loc
 
       let integrity = { valid: false, missingShards: [] };
       if (manifest) {
-        integrity = await verifyIntegrity({ checkHashes: false }).catch(() => ({
-          valid: false,
-          missingShards: [],
-        }));
+        const sourceArtifactFingerprint = buildSourceArtifactFingerprint(manifest);
+        if (sourceArtifactFingerprint) {
+          const sourceIntegrity = await verifyStoredSourceArtifact(manifest, { checkHashes: false }).catch(() => ({
+            valid: false,
+            missingFiles: [],
+          }));
+          integrity = {
+            valid: sourceIntegrity.valid,
+            missingShards: Array.isArray(sourceIntegrity.missingFiles) ? sourceIntegrity.missingFiles : [],
+          };
+        } else {
+          integrity = await verifyIntegrity({ checkHashes: false }).catch(() => ({
+            valid: false,
+            missingShards: [],
+          }));
+        }
       }
 
       if (integrity.valid && manifest && modelUrl) {
-        try {
-          const remoteManifest = await tryFetchRemoteManifest(modelUrl);
-          if (remoteManifest && manifestsDiffer(manifest, remoteManifest)) {
-            log.info('DopplerProvider', 'Cached model differs from source URL manifest; refreshing cache');
-            integrity = { valid: false, missingShards: [] };
-          }
-        } catch (error) {
-          log.warn(
-            'DopplerProvider',
-            `Could not compare cached manifest with source URL (${error.message}); using cached model`
-          );
-        }
+        await verifyExplicitModelUrlMatch(manifest, modelUrl);
       }
 
       if (!integrity.valid && modelUrl) {
@@ -365,7 +430,11 @@ export async function loadModel(modelId, modelUrl = null, onProgress = null, loc
       DopplerCapabilities.kernelsWarmed = true;
     }
 
-    if (!DopplerCapabilities.kernelsTuned && typeof setTimeout !== 'undefined') {
+    if (
+      !DopplerCapabilities.kernelsTuned
+      && shouldAutoTuneKernels()
+      && typeof setTimeout !== 'undefined'
+    ) {
       DopplerCapabilities.kernelsTuned = true;
       const tuneConfig = extractTextModelConfig(manifest);
       setTimeout(() => {
@@ -389,6 +458,9 @@ export async function loadModel(modelId, modelUrl = null, onProgress = null, loc
     const memCaps = await getMemoryCapabilities();
 
     let storageContext = bridgeStorageContext;
+    if (!storageContext && buildSourceArtifactFingerprint(manifest)) {
+      storageContext = createStoredSourceArtifactContext(manifest, { verifyHashes: true });
+    }
     if (!storageContext && useBridge && DopplerCapabilities.bridgeClient && DopplerCapabilities.localPath) {
       const bridgeClient = DopplerCapabilities.bridgeClient;
       const basePath = DopplerCapabilities.localPath.endsWith('/')

package/src/client/doppler-provider/source-runtime.d.ts

@@ -6,7 +6,9 @@ export interface ResolveBridgeSourceRuntimeBundleOptions {
   bridgeClient: ExtensionBridgeClient;
   localPath: string;
   modelId?: string | null;
+  manifest?: RDRRManifest | null;
   onProgress?: (info: { stage: string; message: string }) => void;
+  verifyHashes?: boolean;
 }
 
 export interface BridgeSourceRuntimeBundle {
@@ -19,4 +21,3 @@ export interface BridgeSourceRuntimeBundle {
 export declare function resolveBridgeSourceRuntimeBundle(
   options: ResolveBridgeSourceRuntimeBundleOptions
 ): Promise<BridgeSourceRuntimeBundle | null>;
-

package/src/client/doppler-provider/source-runtime.js

@@ -2,6 +2,7 @@ import {
   createConverterConfig,
   HEADER_READ_SIZE,
 } from '../../config/schema/index.js';
+import { DEFAULT_EXECUTION_V0_SESSION_DEFAULTS } from '../../config/schema/execution-v0.schema.js';
 import { extractArchitecture } from '../../converter/core.js';
 import {
   inferSourceWeightQuantization,
@@ -13,9 +14,11 @@ 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,
+  getSourceRuntimeMetadata,
 } from '../../tooling/source-runtime-bundle.js';
 
 const SUPPORTED_SOURCE_DTYPES = new Set([
@@ -42,6 +45,15 @@ const SOURCE_RUNTIME_EXECUTION_OVERRIDE = {
   ],
 };
 
+const SOURCE_RUNTIME_SESSION_DEFAULTS = {
+  compute: {
+    defaults: { ...DEFAULT_EXECUTION_V0_SESSION_DEFAULTS.compute.defaults },
+    kernelProfiles: [],
+  },
+  kvcache: null,
+  decodeLoop: null,
+};
+
 function normalizeRelativePath(value) {
   return String(value || '')
     .replace(/\\/g, '/')
@@ -166,6 +178,14 @@ async function readBridgeRange(bridgeClient, fileEntry, offset, length) {
   return bridgeClient.read(fileEntry.absolutePath, offset, length);
 }
 
+async function readBridgeAllBytes(bridgeClient, fileEntry, label) {
+  const size = Number(fileEntry?.size) || 0;
+  if (size < 0) {
+    throw new Error(`Invalid bridge file size for ${label}.`);
+  }
+  return readBridgeRange(bridgeClient, fileEntry, 0, size);
+}
+
 async function readBridgeTextFile(bridgeClient, fileEntry, label) {
   const size = Number(fileEntry?.size) || 0;
   if (size <= 0) {
@@ -274,7 +294,39 @@ async function parseBridgeSafetensorsModel(bridgeClient, fileIndex) {
         }
         return { path, size: entry.size };
       }),
+    auxiliaryFiles: [
+      { path: 'config.json', size: Number(fileIndex.get('config.json')?.size || 0), kind: 'config' },
+      ...(fileIndex.has('model.safetensors.index.json')
+        ? [{
+          path: 'model.safetensors.index.json',
+          size: Number(fileIndex.get('model.safetensors.index.json')?.size || 0),
+          kind: 'safetensors_index',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer.json')
+        ? [{
+          path: 'tokenizer.json',
+          size: Number(fileIndex.get('tokenizer.json')?.size || 0),
+          kind: 'tokenizer_json',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer_config.json')
+        ? [{
+          path: 'tokenizer_config.json',
+          size: Number(fileIndex.get('tokenizer_config.json')?.size || 0),
+          kind: 'tokenizer_config',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer.model')
+        ? [{
+          path: 'tokenizer.model',
+          size: Number(fileIndex.get('tokenizer.model')?.size || 0),
+          kind: 'tokenizer_model',
+        }]
+        : []),
+    ],
     tokenizerJsonPath: fileIndex.has('tokenizer.json') ? 'tokenizer.json' : null,
+    tokenizerConfigPath: fileIndex.has('tokenizer_config.json') ? 'tokenizer_config.json' : null,
     tokenizerModelPath: fileIndex.has('tokenizer.model') ? 'tokenizer.model' : null,
   };
 }
@@ -339,7 +391,9 @@ async function parseBridgeGGUFModel(bridgeClient, fileIndex, ggufRelativePath) {
     tokenizerConfig: null,
     tokenizerModelName: null,
     sourceFiles: [{ path: ggufRelativePath, size: ggufEntry.size }],
+    auxiliaryFiles: [],
     tokenizerJsonPath: null,
+    tokenizerConfigPath: null,
     tokenizerModelPath: null,
   };
 }
@@ -391,14 +445,7 @@ function createBridgeFileReaders(bridgeClient, fileMap, rootPath) {
       return null;
     }
     const direct = map.get(hint);
-    if (direct) {
-      return direct;
-    }
-    const basename = hint.split('/').pop();
-    if (basename && map.has(basename)) {
-      return map.get(basename);
-    }
-    return null;
+    return direct || null;
   };
 
   const readRange = async (relativePath, offset, length) => {
@@ -432,10 +479,53 @@ function createBridgeFileReaders(bridgeClient, fileMap, rootPath) {
   };
 }
 
+async function addHashesToBridgeFiles(bridgeClient, fileIndex, entries, hashAlgorithm) {
+  const hashedEntries = [];
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const relativePath = normalizeRelativePath(entry?.path);
+    if (!relativePath) continue;
+    const fileEntry = fileIndex.get(relativePath);
+    if (!fileEntry) {
+      throw new Error(`Missing bridge file entry for "${relativePath}"`);
+    }
+    const bytes = await readBridgeAllBytes(bridgeClient, fileEntry, `bridge source asset (${relativePath})`);
+    hashedEntries.push({
+      ...entry,
+      path: relativePath,
+      size: Number.isFinite(entry?.size) ? Math.max(0, Math.floor(Number(entry.size))) : fileEntry.size,
+      hash: await computeHash(toUint8Array(bytes), hashAlgorithm),
+      hashAlgorithm,
+    });
+  }
+  return hashedEntries;
+}
+
+async function resolveBridgeStorageContext(options = {}) {
+  const bridgeClient = options.bridgeClient;
+  const localPath = options.localPath;
+  const manifest = options.manifest;
+  const sourceRuntime = getSourceRuntimeMetadata(manifest);
+  if (!sourceRuntime) {
+    return null;
+  }
+  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
+  const fileMap = indexBridgeFiles(files);
+  const readers = createBridgeFileReaders(bridgeClient, fileMap, localPath);
+  return createSourceStorageContext({
+    manifest,
+    readRange: readers.readRange,
+    readText: readers.readText,
+    readBinary: readers.readBinary,
+    verifyHashes: options.verifyHashes !== false,
+  });
+}
+
 export async function resolveBridgeSourceRuntimeBundle(options = {}) {
   const bridgeClient = options.bridgeClient;
   const localPath = options.localPath;
   const requestedModelId = options.modelId || null;
+  const verifyHashes = options.verifyHashes !== false;
+  const existingManifest = options.manifest ?? null;
 
   if (!bridgeClient || typeof bridgeClient.read !== 'function' || typeof bridgeClient.list !== 'function') {
     throw new Error('Bridge source runtime requires a connected bridge client with read/list support.');
@@ -444,6 +534,21 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
     throw new Error('Bridge source runtime requires localPath.');
   }
 
+  if (existingManifest && getSourceRuntimeMetadata(existingManifest)) {
+    const storageContext = await resolveBridgeStorageContext({
+      bridgeClient,
+      localPath,
+      manifest: existingManifest,
+      verifyHashes,
+    });
+    return {
+      manifest: existingManifest,
+      storageContext,
+      sourceKind: getSourceRuntimeMetadata(existingManifest)?.sourceKind ?? 'safetensors',
+      sourceRoot: localPath,
+    };
+  }
+
   options.onProgress?.({
     stage: 'source-discovery',
     message: 'Scanning source files via bridge...',
@@ -461,6 +566,7 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
       modelBaseId: requestedModelId || null,
     },
     inference: {
+      sessionDefaults: SOURCE_RUNTIME_SESSION_DEFAULTS,
       execution: SOURCE_RUNTIME_EXECUTION_OVERRIDE,
     },
   });
@@ -476,26 +582,39 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
   });
 
   const modelId = resolveModelIdHint(requestedModelId, plan, parsed.sourceKind);
+  const hashAlgorithm = converterConfig.manifest.hashAlgorithm;
+  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
+  const fileMap = indexBridgeFiles(files);
+  const sourceFiles = await addHashesToBridgeFiles(bridgeClient, fileMap, parsed.sourceFiles, hashAlgorithm);
+  const auxiliaryFiles = await addHashesToBridgeFiles(
+    bridgeClient,
+    fileMap,
+    parsed.auxiliaryFiles,
+    hashAlgorithm
+  );
   const { manifest, shardSources } = await buildSourceRuntimeBundle({
     modelId,
     modelName: modelId,
     modelType: plan.modelType,
+    sourceKind: parsed.sourceKind,
     architecture: parsed.architecture,
     architectureHint: parsed.architectureHint,
     rawConfig: parsed.config,
     inference: plan.manifestInference,
     tensors: parsed.tensors,
-    sourceFiles: parsed.sourceFiles,
+    sourceFiles,
+    auxiliaryFiles,
     sourceQuantization: parsed.sourceQuantization,
     quantizationInfo: plan.quantizationInfo,
-    hashAlgorithm: converterConfig.manifest.hashAlgorithm,
+    hashAlgorithm,
     tokenizerJson: parsed.tokenizerJson,
     tokenizerConfig: parsed.tokenizerConfig,
     tokenizerModelName: parsed.tokenizerModelName,
+    tokenizerJsonPath: parsed.tokenizerJsonPath,
+    tokenizerConfigPath: parsed.tokenizerConfigPath,
+    tokenizerModelPath: parsed.tokenizerModelPath,
   });
 
-  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
-  const fileMap = indexBridgeFiles(files);
   const readers = createBridgeFileReaders(bridgeClient, fileMap, localPath);
   const storageContext = createSourceStorageContext({
     manifest,
@@ -505,7 +624,7 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
     readBinary: readers.readBinary,
     tokenizerJsonPath: parsed.tokenizerJsonPath,
     tokenizerModelPath: parsed.tokenizerModelPath,
-    verifyHashes: false,
+    verifyHashes,
   });
 
   log.info(