@qvac/sdk 0.14.1 → 0.15.0

package/dist/server/rpc/handlers/load-model/registry-download-utils.js

@@ -1,20 +1,20 @@
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { measureChecksum, calculatePercentage, } from "../../../utils/index.js";
-import { getRegistryClient } from "../../../bare/registry/registry-client.js";
-import { getSDKConfig } from "../../../bare/registry/config-registry.js";
-import { buildRegistryClientOptions } from "./registry-client-options.js";
-import { ChecksumValidationFailedError, DownloadCancelledError, } from "../../../../utils/errors-server.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import { measureChecksum, calculatePercentage } from '../../../utils/index.js';
+import { getRegistryClient } from '../../../bare/registry/registry-client.js';
+import { getSDKConfig } from '../../../bare/registry/config-registry.js';
+import { buildRegistryClientOptions } from './registry-client-options.js';
+import { ChecksumValidationFailedError, DownloadCancelledError } from '../../../../utils/errors-server.js';
+import { getServerLogger } from '../../../../logging/index.js';
 const logger = getServerLogger();
-export { DEFAULT_REGISTRY_STREAM_TIMEOUT_MS, buildRegistryClientOptions, } from "./registry-client-options.js";
+export { DEFAULT_REGISTRY_STREAM_TIMEOUT_MS, buildRegistryClientOptions } from './registry-client-options.js';
 export function buildBlobBinding(meta) {
     return {
         coreKey: meta.blobCoreKey,
         blockOffset: meta.blobBlockOffset,
         blockLength: meta.blobBlockLength,
         byteOffset: meta.blobByteOffset,
-        byteLength: meta.expectedSize,
+        byteLength: meta.expectedSize
     };
 }
 /**
@@ -64,13 +64,11 @@ export async function downloadSingleFileFromRegistry(registryPath, registrySourc
         ? (progress) => {
             const total = progress.total || expectedSize || progress.downloaded;
             progressCallback({
-                type: "modelProgress",
+                type: 'modelProgress',
                 downloaded: progress.downloaded,
                 total,
-                percentage: total > 0
-                    ? calculatePercentage(progress.downloaded, total)
-                    : 0,
-                downloadKey,
+                percentage: total > 0 ? calculatePercentage(progress.downloaded, total) : 0,
+                downloadKey
             });
         }
         : undefined;
@@ -78,7 +76,7 @@ export async function downloadSingleFileFromRegistry(registryPath, registrySourc
         sdkConfig: getSDKConfig(),
         outputFile: modelPath,
         onProgress,
-        signal,
+        signal
     });
     if (blobBinding) {
         logger.info(`📥 Downloading blob directly: ${modelFileName}`);
@@ -104,11 +102,11 @@ export async function downloadSingleFileFromRegistry(registryPath, registrySourc
     }
     if (progressCallback) {
         progressCallback({
-            type: "modelProgress",
+            type: 'modelProgress',
             downloaded: stats.size,
             total: stats.size,
             percentage: 100,
-            downloadKey,
+            downloadKey
         });
     }
 }

package/dist/server/rpc/handlers/load-model/registry-metadata.d.ts

@@ -0,0 +1,11 @@
+import type { RegistryItem } from '../../../../models/registry/index';
+export type ExplicitRegistryMetadata = {
+    expectedSize?: number;
+    sha256Checksum?: string;
+};
+export declare function getExplicitRegistryMetadata(modelSrc: unknown): ExplicitRegistryMetadata | undefined;
+export declare function resolveRegistryDownloadMetadata(modelMetadata: RegistryItem | undefined, explicitMetadata: ExplicitRegistryMetadata | undefined, expectedChecksum: string | undefined): {
+    expectedSize: number;
+    checksum: string;
+};
+//# sourceMappingURL=registry-metadata.d.ts.map

package/dist/server/rpc/handlers/load-model/registry-metadata.js

@@ -0,0 +1,23 @@
+import { modelDescriptorSchema } from '../../../../schemas/index.js';
+export function getExplicitRegistryMetadata(modelSrc) {
+    const parsed = modelDescriptorSchema.safeParse(modelSrc);
+    if (!parsed.success || !parsed.data.src.startsWith('registry://')) {
+        return undefined;
+    }
+    const metadata = {};
+    if (typeof parsed.data.expectedSize === 'number') {
+        metadata.expectedSize = parsed.data.expectedSize;
+    }
+    if (typeof parsed.data.sha256Checksum === 'string') {
+        metadata.sha256Checksum = parsed.data.sha256Checksum;
+    }
+    return metadata.expectedSize !== undefined || metadata.sha256Checksum !== undefined
+        ? metadata
+        : undefined;
+}
+export function resolveRegistryDownloadMetadata(modelMetadata, explicitMetadata, expectedChecksum) {
+    return {
+        expectedSize: modelMetadata?.expectedSize ?? explicitMetadata?.expectedSize ?? 0,
+        checksum: modelMetadata?.sha256Checksum ?? expectedChecksum ?? explicitMetadata?.sha256Checksum ?? ''
+    };
+}

package/dist/server/rpc/handlers/load-model/registry.d.ts

@@ -1,4 +1,5 @@
-import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadHooks } from "./types";
-export declare function downloadModelFromRegistry(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, hooks?: DownloadHooks): Promise<string>;
+import type { ModelProgressUpdate } from '../../../../schemas/index';
+import type { DownloadHooks } from './types';
+import { type ExplicitRegistryMetadata } from './registry-metadata';
+export declare function downloadModelFromRegistry(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, hooks?: DownloadHooks, explicitMetadata?: ExplicitRegistryMetadata): Promise<string>;
 //# sourceMappingURL=registry.d.ts.map

package/dist/server/rpc/handlers/load-model/registry.js

@@ -1,47 +1,46 @@
-import { promises as fsPromises } from "bare-fs";
-import { generateShortHash, detectShardedModel, getShardedModelCacheDir, getShardPath, extractTensorsFromShards, calculatePercentage, } from "../../../utils/index.js";
-import { getSingleFileCachePath } from "../../../utils/cache/paths.js";
-import { getModelByPath } from "../../../../models/registry/index.js";
-import { getRegistryClient } from "../../../bare/registry/registry-client.js";
-import { createRegistryDownloadKey, startOrJoinDownload, applyJoinedDownloadStats, } from "./download-manager.js";
-import { buildBlobBinding, validateCachedFile, downloadSingleFileFromRegistry, } from "./registry-download-utils.js";
-import { downloadCompanionSetFromRegistry } from "./registry-companion-set.js";
-import { DownloadCancelledError, ModelNotFoundError, RegistryDownloadFailedError, } from "../../../../utils/errors-server.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import { promises as fsPromises } from 'bare-fs';
+import { generateShortHash, detectShardedModel, getShardedModelCacheDir, getShardPath, extractTensorsFromShards, calculatePercentage } from '../../../utils/index.js';
+import { getSingleFileCachePath } from '../../../utils/cache/paths.js';
+import { getModelByPath } from '../../../../models/registry/index.js';
+import { getRegistryClient } from '../../../bare/registry/registry-client.js';
+import { createRegistryDownloadKey, startOrJoinDownload, applyJoinedDownloadStats } from './download-manager.js';
+import { buildBlobBinding, validateCachedFile, downloadSingleFileFromRegistry } from './registry-download-utils.js';
+import { downloadCompanionSetFromRegistry } from './registry-companion-set.js';
+import { DownloadCancelledError, ModelNotFoundError, RegistryDownloadFailedError } from '../../../../utils/errors-server.js';
+import { getServerLogger } from '../../../../logging/index.js';
+import { resolveRegistryDownloadMetadata } from './registry-metadata.js';
 const logger = getServerLogger();
 /**
  * Find all shards for a model using path prefix query.
  */
 async function findModelShards(registryPath) {
     const client = await getRegistryClient();
-    const shardInfo = detectShardedModel(registryPath.split("/").pop() || "");
+    const shardInfo = detectShardedModel(registryPath.split('/').pop() || '');
     if (!shardInfo.isSharded) {
         throw new RegistryDownloadFailedError(`Not a sharded model path: ${registryPath}`);
     }
-    const pathPrefix = registryPath.replace(/-\d{5}-of-\d{5}\./, ".");
-    const basePath = pathPrefix.substring(0, pathPrefix.lastIndexOf("."));
+    const pathPrefix = registryPath.replace(/-\d{5}-of-\d{5}\./, '.');
+    const basePath = pathPrefix.substring(0, pathPrefix.lastIndexOf('.'));
     logger.info(`🔍 Finding shards with prefix: ${basePath}`);
     const shards = await client.findModels({
         gte: { path: basePath },
-        lte: { path: basePath + "\uffff" },
+        lte: { path: basePath + '\uffff' }
     });
     const sortedShards = shards
         .filter((s) => {
-        const info = detectShardedModel(s.path.split("/").pop() || "");
+        const info = detectShardedModel(s.path.split('/').pop() || '');
         return info.isSharded;
     })
         .sort((a, b) => {
-        const aInfo = detectShardedModel(a.path.split("/").pop() || "");
-        const bInfo = detectShardedModel(b.path.split("/").pop() || "");
+        const aInfo = detectShardedModel(a.path.split('/').pop() || '');
+        const bInfo = detectShardedModel(b.path.split('/').pop() || '');
         return (aInfo.currentShard || 0) - (bInfo.currentShard || 0);
     })
         .map((s) => ({
         path: s.path,
         source: s.source,
         size: s.blobBinding?.byteLength || 0,
-        checksum: s.blobBinding?.["sha256"] ||
-            s.sha256 ||
-            "",
+        checksum: s.blobBinding?.['sha256'] || s.sha256 || ''
     }));
     logger.info(`📦 Found ${sortedShards.length} shards`);
     return sortedShards;
@@ -63,11 +62,11 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
             checksum: shard.sha256Checksum,
             path: registryPath,
             source: registrySource,
-            blobBinding: buildBlobBinding(shard),
+            blobBinding: buildBlobBinding(shard)
         }));
     }
     else {
-        const filename = registryPath.split("/").pop() || registryPath;
+        const filename = registryPath.split('/').pop() || registryPath;
         const shardInfo = detectShardedModel(filename);
         if (!shardInfo.isSharded || !shardInfo.totalShards) {
             throw new RegistryDownloadFailedError(`Not a sharded model: ${filename}`);
@@ -80,11 +79,11 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
             logger.warn(`⚠️ Expected ${shardInfo.totalShards} shards but found ${remoteShards.length}`);
         }
         shards = remoteShards.map((s) => ({
-            filename: s.path.split("/").pop() || "",
+            filename: s.path.split('/').pop() || '',
             size: s.size,
             checksum: s.checksum,
             path: s.path,
-            source: s.source,
+            source: s.source
         }));
     }
     const shardDir = getShardedModelCacheDir(cacheKey);
@@ -104,7 +103,7 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
             overallDownloaded += shard.size;
             if (progressCallback) {
                 progressCallback({
-                    type: "modelProgress",
+                    type: 'modelProgress',
                     downloaded: shard.size,
                     total: shard.size,
                     percentage: 100,
@@ -115,8 +114,8 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
                         shardName: shard.filename,
                         overallDownloaded,
                         overallTotal,
-                        overallPercentage: calculatePercentage(overallDownloaded, overallTotal),
-                    },
+                        overallPercentage: calculatePercentage(overallDownloaded, overallTotal)
+                    }
                 });
             }
             continue;
@@ -134,8 +133,8 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
                         shardName: shard.filename,
                         overallDownloaded: currentOverall,
                         overallTotal,
-                        overallPercentage: calculatePercentage(currentOverall, overallTotal),
-                    },
+                        overallPercentage: calculatePercentage(currentOverall, overallTotal)
+                    }
                 });
             }
             : undefined;
@@ -148,7 +147,7 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
     if (progressCallback) {
         const lastShard = shards[shards.length - 1];
         progressCallback({
-            type: "modelProgress",
+            type: 'modelProgress',
             downloaded: overallTotal,
             total: overallTotal,
             percentage: 100,
@@ -159,16 +158,16 @@ async function downloadShardedFilesFromRegistry(registryPath, registrySource, ca
                 shardName: lastShard.filename,
                 overallDownloaded: overallTotal,
                 overallTotal,
-                overallPercentage: 100,
-            },
+                overallPercentage: 100
+            }
         });
     }
     return getShardPath(cacheKey, firstShardFilename);
 }
-export async function downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks) {
+export async function downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata) {
     const downloadKey = createRegistryDownloadKey(registrySource, registryPath);
     hooks?.onDownloadKey?.(downloadKey);
-    const filename = registryPath.split("/").pop() || registryPath;
+    const filename = registryPath.split('/').pop() || registryPath;
     const shardInfo = detectShardedModel(filename);
     // Look up model metadata from our generated models.ts
     const modelMetadata = getModelByPath(registryPath);
@@ -194,7 +193,7 @@ export async function downloadModelFromRegistry(registryPath, registrySource, pr
                     ctx.setCacheHit(true);
                     const overallTotal = localShardMeta.reduce((sum, s) => sum + s.expectedSize, 0);
                     ctx.broadcastProgress({
-                        type: "modelProgress",
+                        type: 'modelProgress',
                         downloaded: overallTotal,
                         total: overallTotal,
                         percentage: 100,
@@ -205,8 +204,8 @@ export async function downloadModelFromRegistry(registryPath, registrySource, pr
                             shardName: firstShardFilename,
                             overallDownloaded: overallTotal,
                             overallTotal,
-                            overallPercentage: 100,
-                        },
+                            overallPercentage: 100
+                        }
                     });
                     return getShardPath(cacheKey, firstShardFilename);
                 }
@@ -217,18 +216,17 @@ export async function downloadModelFromRegistry(registryPath, registrySource, pr
                 return await downloadShardedFilesFromRegistry(registryPath, registrySource, cacheKey, ctx.broadcastProgress, ctx.signal, localShardMeta, hooks);
             }
             catch (error) {
-                if (error instanceof DownloadCancelledError &&
-                    ctx.shouldClearCache()) {
+                if (error instanceof DownloadCancelledError && ctx.shouldClearCache()) {
                     try {
                         await fsPromises.rm(getShardedModelCacheDir(cacheKey), {
                             recursive: true,
-                            force: true,
+                            force: true
                         });
                     }
                     catch (cleanupError) {
-                        logger.debug("Failed to delete shard cache dir during cleanup", {
+                        logger.debug('Failed to delete shard cache dir during cleanup', {
                             cacheKey,
-                            error: cleanupError,
+                            error: cleanupError
                         });
                     }
                 }
@@ -246,53 +244,49 @@ export async function downloadModelFromRegistry(registryPath, registrySource, pr
                 markCacheMiss: () => {
                     hooks?.markCacheMiss?.();
                     ctx.setCacheHit(false);
-                },
+                }
             };
             return await downloadCompanionSetFromRegistry({
                 companionSet: modelMetadata.companionSet,
                 downloadKey,
-                allowLegacyFlatCache: modelMetadata.addon === "nmt",
+                allowLegacyFlatCache: modelMetadata.addon === 'nmt',
                 progressCallback: ctx.broadcastProgress,
                 signal: ctx.signal,
                 hooks: companionHooks,
-                shouldClearCache: ctx.shouldClearCache,
+                shouldClearCache: ctx.shouldClearCache
             });
         }
         const modelPath = getSingleFileCachePath(registryPath);
-        const expectedSize = modelMetadata?.expectedSize || 0;
-        const checksum = expectedChecksum || modelMetadata?.sha256Checksum || "";
+        const { expectedSize, checksum } = resolveRegistryDownloadMetadata(modelMetadata, explicitMetadata, expectedChecksum);
         const cachedPath = await validateCachedFile(modelPath, filename, expectedSize, checksum, hooks);
         if (cachedPath) {
             logger.info(`✅ Using cached model: ${cachedPath}`);
             hooks?.markCacheHit?.();
             ctx.setCacheHit(true);
             ctx.broadcastProgress({
-                type: "modelProgress",
+                type: 'modelProgress',
                 downloaded: expectedSize,
                 total: expectedSize,
                 percentage: 100,
-                downloadKey,
+                downloadKey
             });
             return cachedPath;
         }
-        const blobBinding = modelMetadata
-            ? buildBlobBinding(modelMetadata)
-            : undefined;
+        const blobBinding = modelMetadata ? buildBlobBinding(modelMetadata) : undefined;
         hooks?.markCacheMiss?.();
         ctx.setCacheHit(false);
         try {
             await downloadSingleFileFromRegistry(registryPath, registrySource, modelPath, filename, downloadKey, expectedSize, checksum, ctx.broadcastProgress, ctx.signal, blobBinding, hooks);
         }
         catch (error) {
-            if (error instanceof DownloadCancelledError &&
-                ctx.shouldClearCache()) {
+            if (error instanceof DownloadCancelledError && ctx.shouldClearCache()) {
                 try {
                     await fsPromises.unlink(modelPath);
                 }
                 catch (cleanupError) {
-                    logger.debug("Failed to delete model file during cleanup", {
+                    logger.debug('Failed to delete model file during cleanup', {
                         path: modelPath,
-                        error: cleanupError,
+                        error: cleanupError
                     });
                 }
             }

package/dist/server/rpc/handlers/load-model/resolve-session.d.ts

@@ -1,6 +1,6 @@
-import type { AbortSignal } from "bare-abort-controller";
-import type { ModelProgressUpdate, ResolveContext } from "../../../../schemas/index";
-import type { DownloadRequestBinding, ResolveResult } from "./types";
+import type { AbortSignal } from 'bare-abort-controller';
+import type { ModelProgressUpdate, ResolveContext } from '../../../../schemas/index';
+import type { DownloadRequestBinding, ResolveResult } from './types';
 export interface ResolveSessionOptions {
     progressCallback?: ((update: ModelProgressUpdate) => void) | undefined;
     seed?: boolean | undefined;

package/dist/server/rpc/handlers/load-model/resolve-session.js

@@ -1,6 +1,6 @@
-import { resolveModelPath, resolveModelPathWithStats, } from "./resolve.js";
-import { cancelTransfer } from "./download-manager.js";
-import { mergeDownloadStats } from "./download-stats.js";
+import { resolveModelPath, resolveModelPathWithStats } from './resolve.js';
+import { cancelTransfer } from './download-manager.js';
+import { mergeDownloadStats } from './download-stats.js';
 export function createResolveSession(options) {
     const { progressCallback, seed, profilingEnabled, signal, requestBinding } = options;
     let primaryResult;
@@ -10,7 +10,7 @@ export function createResolveSession(options) {
         onDownloadKey(key) {
             activeDownloadKeys.add(key);
         },
-        ...(requestBinding !== undefined && { requestBinding }),
+        ...(requestBinding !== undefined && { requestBinding })
     };
     async function resolvePrimaryModelPath(modelSrc) {
         if (profilingEnabled) {
@@ -34,7 +34,7 @@ export function createResolveSession(options) {
             resolveModelPath: resolveForPlugin,
             modelSrc,
             modelType,
-            ...(modelName !== undefined && { modelName }),
+            ...(modelName !== undefined && { modelName })
         };
     }
     function getAggregateResult() {
@@ -44,7 +44,7 @@ export function createResolveSession(options) {
         return {
             path: primaryResult?.path ?? resolveResults[0].path,
             sourceType: primaryResult?.sourceType ?? resolveResults[0].sourceType,
-            ...(downloadStats !== undefined && { downloadStats }),
+            ...(downloadStats !== undefined && { downloadStats })
         };
     }
     function cancelAll() {
@@ -57,6 +57,6 @@ export function createResolveSession(options) {
         resolvePrimaryModelPath,
         createResolveContext,
         getAggregateResult,
-        cancelAll,
+        cancelAll
     };
 }

package/dist/server/rpc/handlers/load-model/resolve.d.ts

@@ -1,6 +1,6 @@
-import { type ModelProgressUpdate } from "../../../../schemas/index";
-import type { ResolveResult, DownloadHooks } from "./types";
-import type { AbortSignal } from "bare-abort-controller";
+import { type ModelProgressUpdate } from '../../../../schemas/index';
+import type { ResolveResult, DownloadHooks } from './types';
+import type { AbortSignal } from 'bare-abort-controller';
 export declare function resolveModelPath(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<string>;
 export declare function resolveModelPathWithStats(modelSrc: unknown, progressCallback?: (progress: ModelProgressUpdate) => void, seed?: boolean, signal?: AbortSignal, hooks?: DownloadHooks): Promise<ResolveResult>;
 //# sourceMappingURL=resolve.d.ts.map

package/dist/server/rpc/handlers/load-model/resolve.js

@@ -1,16 +1,17 @@
-import { models, getModelByPath } from "../../../../models/registry/models.js";
-import { hyperdriveUrlSchema, registryUrlSchema, SUPPORTED_ARCHIVE_EXTENSIONS, } from "../../../../schemas/index.js";
-import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive, } from "../../../utils/index.js";
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { downloadModelFromHttp } from "./http.js";
-import { downloadModelFromHyperdrive } from "./hyperdrive.js";
-import { downloadModelFromRegistry } from "./registry.js";
-import { downloadModelFromHttpWithStats, downloadModelFromHyperdriveWithStats, downloadModelFromRegistryWithStats, } from "./download-stats.js";
-import { InferenceCancelledError, ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
-import { validateAndJoinPath } from "../../../utils/path-security.js";
-import { getServerLogger } from "../../../../logging/index.js";
-import { modelInputToSrcSchema } from "../../../../schemas/index.js";
+import { models, getModelByPath } from '../../../../models/registry/models.js';
+import { hyperdriveUrlSchema, registryUrlSchema, SUPPORTED_ARCHIVE_EXTENSIONS } from '../../../../schemas/index.js';
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, extractAndValidateShardedArchive } from '../../../utils/index.js';
+import { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import { downloadModelFromHttp } from './http.js';
+import { downloadModelFromHyperdrive } from './hyperdrive.js';
+import { downloadModelFromRegistry } from './registry.js';
+import { getExplicitRegistryMetadata } from './registry-metadata.js';
+import { downloadModelFromHttpWithStats, downloadModelFromHyperdriveWithStats, downloadModelFromRegistryWithStats } from './download-stats.js';
+import { InferenceCancelledError, ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError } from '../../../../utils/errors-server.js';
+import { validateAndJoinPath } from '../../../utils/path-security.js';
+import { getServerLogger } from '../../../../logging/index.js';
+import { modelInputToSrcSchema } from '../../../../schemas/index.js';
 const logger = getServerLogger();
 function isArchivePath(filePath) {
     const filename = path.basename(filePath).toLowerCase();
@@ -59,12 +60,12 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
         catch {
             // Invalid model ID - provide helpful error
             const availableModels = models.map((m) => m.modelId);
-            throw new ModelNotFoundError(`${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
+            throw new ModelNotFoundError(`${modelIdOrPath}". Available models: ${availableModels.join(', ')}`);
         }
     }
 }
 function isDownloadResult(value) {
-    return value !== null && typeof value === "object" && "path" in value;
+    return value !== null && typeof value === 'object' && 'path' in value;
 }
 function buildResult(pathOrResult, sourceType) {
     if (isDownloadResult(pathOrResult)) {
@@ -76,7 +77,7 @@ function buildResult(pathOrResult, sourceType) {
 }
 async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, signal, hooks) {
     if (signal?.aborted) {
-        throw new InferenceCancelledError(hooks?.requestBinding?.requestId ?? "unknown");
+        throw new InferenceCancelledError(hooks?.requestBinding?.requestId ?? 'unknown');
     }
     const srcString = modelInputToSrcSchema.parse(modelSrc);
     // Empty modelSrc is reserved for plugins that ship bundled weights
@@ -85,55 +86,55 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, sign
     // somehow gets called we return an empty path so the plugin's
     // `params.modelPath` falls through to undefined instead of being set
     // to the cache directory itself.
-    if (srcString === "") {
-        return { path: "", sourceType: "filesystem" };
+    if (srcString === '') {
+        return { path: '', sourceType: 'filesystem' };
     }
     // Parse hyperdrive URLs if present
     let hyperdriveKey;
     let actualModelSrc = srcString;
-    if (srcString.startsWith("pear://")) {
+    if (srcString.startsWith('pear://')) {
         const { key, path: pathValue } = hyperdriveUrlSchema.parse(srcString);
         hyperdriveKey = key;
         actualModelSrc = pathValue;
     }
     // Registry source
-    if (srcString.startsWith("registry://")) {
+    if (srcString.startsWith('registry://')) {
         const { registryPath, registrySource } = registryUrlSchema.parse(srcString);
         logger.info(`Loading from registry: ${registryPath}`);
         // Look up model metadata for checksum validation
         const modelMetadata = getModelByPath(registryPath);
-        const expectedChecksum = modelMetadata?.sha256Checksum;
-        const result = mode === "stats"
-            ? await downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, hooks)
-            : await downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks);
+        const explicitMetadata = getExplicitRegistryMetadata(modelSrc);
+        const expectedChecksum = modelMetadata?.sha256Checksum ?? explicitMetadata?.sha256Checksum;
+        const result = mode === 'stats'
+            ? await downloadModelFromRegistryWithStats(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata)
+            : await downloadModelFromRegistry(registryPath, registrySource, progressCallback, expectedChecksum, hooks, explicitMetadata);
         logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
-        return buildResult(result, "registry");
+        return buildResult(result, 'registry');
     }
     // Validate seeding is only used with hyperdrive models
     if (seed && !hyperdriveKey) {
         throw new SeedingNotSupportedError();
     }
     // HTTP source
-    if (actualModelSrc.startsWith("http://") ||
-        actualModelSrc.startsWith("https://")) {
+    if (actualModelSrc.startsWith('http://') || actualModelSrc.startsWith('https://')) {
         logger.info(`Loading from HTTP URL: ${actualModelSrc}`);
-        const result = mode === "stats"
+        const result = mode === 'stats'
             ? await downloadModelFromHttpWithStats(actualModelSrc, progressCallback, hooks)
             : await downloadModelFromHttp(actualModelSrc, progressCallback, hooks);
         logger.info(`Loaded Model to ${isDownloadResult(result) ? result.path : result}`);
-        return buildResult(result, "http");
+        return buildResult(result, 'http');
     }
     // Hyperdrive source
     if (hyperdriveKey) {
         logger.info(`Loading from hyperdrive: ${hyperdriveKey}`);
-        const result = mode === "stats"
+        const result = mode === 'stats'
             ? await downloadModelFromHyperdriveWithStats(hyperdriveKey, actualModelSrc, seed, progressCallback, hooks)
             : await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback, hooks);
-        return buildResult(result, "hyperdrive");
+        return buildResult(result, 'hyperdrive');
     }
     // Filesystem source (local files, cached files)
     let resolvedPath;
-    if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
+    if (actualModelSrc.includes('/') || actualModelSrc.includes('\\')) {
         if (isArchivePath(actualModelSrc)) {
             logger.info(`Extracting local archive: ${actualModelSrc}`);
             const archiveHash = generateShortHash(actualModelSrc);
@@ -147,12 +148,12 @@ async function resolveModelPathCore(modelSrc, progressCallback, seed, mode, sign
     else {
         resolvedPath = await resolveLocalOrCachedFile(actualModelSrc);
     }
-    return { path: resolvedPath, sourceType: "filesystem" };
+    return { path: resolvedPath, sourceType: 'filesystem' };
 }
 export async function resolveModelPath(modelSrc, progressCallback, seed, signal, hooks) {
-    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, "base", signal, hooks);
+    const result = await resolveModelPathCore(modelSrc, progressCallback, seed, 'base', signal, hooks);
     return result.path;
 }
 export async function resolveModelPathWithStats(modelSrc, progressCallback, seed, signal, hooks) {
-    return resolveModelPathCore(modelSrc, progressCallback, seed, "stats", signal, hooks);
+    return resolveModelPathCore(modelSrc, progressCallback, seed, 'stats', signal, hooks);
 }

package/dist/server/rpc/handlers/load-model/types.d.ts

@@ -1,6 +1,6 @@
-import type { SourceType } from "../../../../schemas/index";
-import type { AbortSignal } from "bare-abort-controller";
-import type { DisposableScope } from "../../../bare/runtime/disposable-scope";
+import type { SourceType } from '../../../../schemas/index';
+import type { AbortSignal } from 'bare-abort-controller';
+import type { DisposableScope } from '../../../bare/runtime/disposable-scope';
 export interface DownloadStats {
     downloadTimeMs?: number;
     totalBytesDownloaded?: number;

package/dist/server/rpc/handlers/load-model/types.js

@@ -3,26 +3,26 @@ export function buildDownloadProfilingFields(downloadStats, sourceType) {
     const tags = {};
     if (downloadStats) {
         if (downloadStats.downloadTimeMs !== undefined) {
-            gauges["downloadTime"] = downloadStats.downloadTimeMs;
+            gauges['downloadTime'] = downloadStats.downloadTimeMs;
         }
         if (downloadStats.totalBytesDownloaded !== undefined) {
-            gauges["totalBytesDownloaded"] = downloadStats.totalBytesDownloaded;
+            gauges['totalBytesDownloaded'] = downloadStats.totalBytesDownloaded;
         }
         if (downloadStats.downloadSpeedBps !== undefined) {
-            gauges["downloadSpeedBps"] = downloadStats.downloadSpeedBps;
+            gauges['downloadSpeedBps'] = downloadStats.downloadSpeedBps;
         }
         if (downloadStats.checksumValidationTimeMs !== undefined) {
-            gauges["checksumValidationTime"] = downloadStats.checksumValidationTimeMs;
+            gauges['checksumValidationTime'] = downloadStats.checksumValidationTimeMs;
         }
         if (downloadStats.cacheHit !== undefined) {
-            tags["cacheHit"] = downloadStats.cacheHit ? "true" : "false";
+            tags['cacheHit'] = downloadStats.cacheHit ? 'true' : 'false';
         }
         if (downloadStats.sharedTransfer) {
-            tags["sharedTransfer"] = "true";
+            tags['sharedTransfer'] = 'true';
         }
     }
     if (sourceType) {
-        tags["sourceType"] = sourceType;
+        tags['sourceType'] = sourceType;
     }
     return { gauges, tags };
 }