@qvac/sdk 0.9.1 → 0.10.0

package/dist/server/rpc/handlers/get-model-info.js

@@ -1,10 +1,9 @@
 import { models } from "../../../models/registry/models.js";
 import { getAllModelIds, getModelEntry, } from "../../bare/registry/model-registry.js";
-import { getConfiguredCacheDir } from "../../bare/registry/config-registry.js";
 import { generateShortHash } from "../../utils/index.js";
 import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { getShardPath } from "../../utils/cache.js";
+import { getShardPath, getModelsCacheDir, getSingleFileCachePath, } from "../../utils/cache/paths.js";
+import { validateAndJoinPath } from "../../utils/path-security.js";
 import { ModelNotFoundError } from "../../../utils/errors-server.js";
 export async function handleGetModelInfo(request) {
     const { name } = request;
@@ -15,16 +14,19 @@ export async function handleGetModelInfo(request) {
     const cacheKey = generateShortHash(catalogEntry.registryPath);
     const cacheStatus = catalogEntry.shardMetadata && catalogEntry.shardMetadata.length > 0
         ? await handleShardedModel(cacheKey, catalogEntry.shardMetadata)
-        : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
-    const { cacheFiles, isCached, actualSize, cachedAt } = cacheStatus;
+        : catalogEntry.companionSet
+            ? await handleCompanionSetModel(catalogEntry.companionSet, catalogEntry.registryPath)
+            : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
+    const { cacheFiles, isCached, actualSize, cachedAt, primaryPath } = cacheStatus;
     const loadedModelIds = getAllModelIds();
+    const matchPath = primaryPath ?? cacheFiles[0]?.path;
     const loadedInstances = [];
     for (const id of loadedModelIds) {
         const entry = getModelEntry(id);
-        if (!entry?.local)
+        if (!entry || entry.isDelegated)
             continue;
         const matchesByName = entry.local.name && entry.local.name === name;
-        const matchesByPath = cacheFiles.length > 0 && entry.local.path === cacheFiles[0]?.path;
+        const matchesByPath = !!matchPath && entry.local.path === matchPath;
         if (matchesByName || matchesByPath) {
             const instance = {
                 registryId: id,
@@ -63,55 +65,100 @@ export async function handleGetModelInfo(request) {
     };
 }
 async function handleShardedModel(cacheKey, shardMetadata) {
+    const fileEntries = shardMetadata.map((s) => ({
+        filename: s.filename,
+        expectedSize: s.expectedSize,
+        sha256Checksum: s.sha256Checksum,
+    }));
+    const paths = shardMetadata.map((s) => getShardPath(cacheKey, s.filename));
+    return checkCacheStatus(fileEntries, paths);
+}
+async function handleCompanionSetModel(companionSet, primaryRegistryPath) {
+    const { setKey, primaryKey, files } = companionSet;
+    const baseCache = getModelsCacheDir();
+    const fileEntries = files.map((f) => ({
+        filename: f.targetName,
+        expectedSize: f.expectedSize,
+        sha256Checksum: f.sha256Checksum,
+        key: f.key,
+    }));
+    const canonicalPaths = files.map((f) => validateAndJoinPath(baseCache, "sets", setKey, f.targetName));
+    const canonicalResult = await checkCacheStatus(fileEntries, canonicalPaths, primaryKey);
+    if (canonicalResult.isCached)
+        return canonicalResult;
+    const isOnnxSet = files.some((f) => f.primary === true && f.targetName.endsWith(".onnx"));
+    if (isOnnxSet) {
+        const legacyCacheKey = generateShortHash(primaryRegistryPath);
+        const legacyPaths = files.map((f) => validateAndJoinPath(baseCache, "onnx", legacyCacheKey, f.targetName));
+        const legacyResult = await checkCacheStatus(fileEntries, legacyPaths, primaryKey);
+        if (legacyResult.isCached)
+            return legacyResult;
+    }
+    else {
+        // Legacy flat-cache compatibility for Bergamot-style companion sets.
+        // This is valid only for families whose runtime still works with explicit
+        // per-file absolute paths; it is not a generic rule for all companion sets.
+        const flatPaths = files.map((f) => getSingleFileCachePath(f.registryPath));
+        const flatResult = await checkCacheStatus(fileEntries, flatPaths, primaryKey);
+        if (flatResult.isCached)
+            return flatResult;
+    }
+    return canonicalResult;
+}
+async function checkCacheStatus(files, paths, primaryKey) {
     const cacheFiles = [];
-    let allShardsCached = true;
+    let allCached = true;
     let totalActualSize = 0;
     let latestCachedAt;
-    for (const shard of shardMetadata) {
-        const shardPath = getShardPath(cacheKey, shard.filename);
-        let shardIsCached = false;
-        let shardActualSize;
-        let shardCachedAt;
+    let primaryPath;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const filePath = paths[i];
+        let fileCached = false;
+        let fileActualSize;
+        let fileCachedAt;
         try {
-            const stats = await fsPromises.stat(shardPath);
-            const fileExists = stats.isFile();
-            if (fileExists) {
-                shardActualSize = stats.size;
-                shardCachedAt = stats.mtime;
-                shardIsCached = stats.size === shard.expectedSize;
-                if (shardIsCached) {
-                    totalActualSize += stats.size;
-                    if (!latestCachedAt || stats.mtime > latestCachedAt) {
-                        latestCachedAt = stats.mtime;
-                    }
-                }
-                else {
-                    allShardsCached = false;
-                }
-            }
-            else {
-                allShardsCached = false;
+            const stats = await fsPromises.stat(filePath);
+            if (stats.isFile()) {
+                fileActualSize = stats.size;
+                fileCachedAt = stats.mtime;
+                fileCached = stats.size === file.expectedSize;
             }
         }
         catch {
-            shardIsCached = false;
-            allShardsCached = false;
+            // file does not exist
+        }
+        if (primaryKey && file.key === primaryKey) {
+            primaryPath = filePath;
+        }
+        if (fileCached) {
+            totalActualSize += fileActualSize;
+            if (!latestCachedAt || fileCachedAt > latestCachedAt) {
+                latestCachedAt = fileCachedAt;
+            }
+        }
+        else {
+            allCached = false;
         }
         cacheFiles.push({
-            filename: shard.filename,
-            path: shardPath,
-            expectedSize: shard.expectedSize,
-            sha256Checksum: shard.sha256Checksum,
-            isCached: shardIsCached,
-            actualSize: shardActualSize,
-            cachedAt: shardCachedAt,
+            filename: file.filename,
+            path: filePath,
+            expectedSize: file.expectedSize,
+            sha256Checksum: file.sha256Checksum,
+            isCached: fileCached,
+            actualSize: fileActualSize,
+            cachedAt: fileCachedAt,
         });
     }
+    if (!primaryPath && cacheFiles.length > 0) {
+        primaryPath = cacheFiles[0].path;
+    }
     const result = {
         cacheFiles,
-        isCached: allShardsCached,
+        isCached: allCached,
+        primaryPath,
     };
-    if (allShardsCached) {
+    if (allCached) {
         result.actualSize = totalActualSize;
         if (latestCachedAt) {
             result.cachedAt = latestCachedAt;
@@ -119,46 +166,8 @@ async function handleShardedModel(cacheKey, shardMetadata) {
     }
     return result;
 }
-async function handleSingleFileModel(registryPath, modelId, expectedSize, sha256Checksum) {
-    const cacheDir = getConfiguredCacheDir();
-    // Use registryPath for hash to match download logic in registry.ts
-    const sourceHash = generateShortHash(registryPath);
-    const filePath = path.join(cacheDir, `${sourceHash}_${modelId}`);
-    let fileIsCached = false;
-    let fileActualSize;
-    let fileCachedAt;
-    try {
-        const stats = await fsPromises.stat(filePath);
-        const fileExists = stats.isFile();
-        if (fileExists) {
-            fileActualSize = stats.size;
-            fileCachedAt = stats.mtime;
-            fileIsCached = stats.size === expectedSize;
-        }
-    }
-    catch {
-        fileIsCached = false;
-    }
-    const cacheFiles = [
-        {
-            filename: modelId,
-            path: filePath,
-            expectedSize,
-            sha256Checksum,
-            isCached: fileIsCached,
-            actualSize: fileActualSize,
-            cachedAt: fileCachedAt,
-        },
-    ];
-    const result = {
-        cacheFiles,
-        isCached: fileIsCached,
-    };
-    if (fileActualSize !== undefined) {
-        result.actualSize = fileActualSize;
-    }
-    if (fileCachedAt !== undefined) {
-        result.cachedAt = fileCachedAt;
-    }
-    return result;
+async function handleSingleFileModel(registryPath, expectedSize, sha256Checksum) {
+    const filename = registryPath.split("/").pop() || registryPath;
+    const filePath = getSingleFileCachePath(registryPath);
+    return checkCacheStatus([{ filename, expectedSize, sha256Checksum }], [filePath]);
 }

package/dist/server/rpc/handlers/heartbeat-delegated.js

@@ -8,9 +8,9 @@ export async function handleHeartbeatDelegated(request, options) {
     if (!delegate) {
         throw new DelegateConnectionFailedError("Delegated heartbeat handler called without delegate info");
     }
-    const { topic, providerPublicKey, timeout } = delegate;
+    const { providerPublicKey, timeout } = delegate;
     try {
-        const rpc = await getRPC(topic, providerPublicKey, { timeout });
+        const rpc = await getRPC(providerPublicKey, { timeout });
         const delegateOpts = {
             peerKey: providerPublicKey,
         };

package/dist/server/rpc/handlers/index.d.ts

@@ -13,7 +13,9 @@ import { handleRag } from "./rag";
 import { cancelHandler } from "./cancelHandler";
 import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
+import { handleTextToSpeechStream } from "./text-to-speech-stream";
 import { handleGetModelInfo } from "./get-model-info";
+import { handleGetLoadedModelInfo } from "./get-loaded-model-info";
 import { handleFinetune } from "./finetune";
 import { handleOCRStream } from "./ocr-stream";
 import { handleHeartbeat } from "./heartbeat";
@@ -22,6 +24,7 @@ import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
 import { handleSuspend } from "./suspend";
 import { handleResume } from "./resume";
+import { handleState } from "./state";
 export declare const handlers: {
     heartbeat: typeof handleHeartbeat;
     completionStream: typeof handleCompletionStream;
@@ -39,7 +42,9 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
+    textToSpeechStream: typeof handleTextToSpeechStream;
     getModelInfo: typeof handleGetModelInfo;
+    getLoadedModelInfo: typeof handleGetLoadedModelInfo;
     finetune: typeof handleFinetune;
     ocrStream: typeof handleOCRStream;
     diffusionStream: typeof handleDiffusionStream;
@@ -50,5 +55,6 @@ export declare const handlers: {
     modelRegistryGetModel: typeof handleModelRegistryGetModel;
     suspend: typeof handleSuspend;
     resume: typeof handleResume;
+    state: typeof handleState;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/handlers/index.js

@@ -13,7 +13,9 @@ import { handleRag } from "./rag.js";
 import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
+import { handleTextToSpeechStream } from "./text-to-speech-stream.js";
 import { handleGetModelInfo } from "./get-model-info.js";
+import { handleGetLoadedModelInfo } from "./get-loaded-model-info.js";
 import { handleFinetune } from "./finetune.js";
 import { handleOCRStream } from "./ocr-stream.js";
 import { handleHeartbeat } from "./heartbeat.js";
@@ -22,6 +24,7 @@ import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
 import { handleSuspend } from "./suspend.js";
 import { handleResume } from "./resume.js";
+import { handleState } from "./state.js";
 export const handlers = {
     heartbeat: handleHeartbeat,
     completionStream: handleCompletionStream,
@@ -39,7 +42,9 @@ export const handlers = {
     rag: handleRag,
     cancel: cancelHandler,
     textToSpeech: handleTextToSpeech,
+    textToSpeechStream: handleTextToSpeechStream,
     getModelInfo: handleGetModelInfo,
+    getLoadedModelInfo: handleGetLoadedModelInfo,
     finetune: handleFinetune,
     ocrStream: handleOCRStream,
     diffusionStream: handleDiffusionStream,
@@ -50,4 +55,5 @@ export const handlers = {
     modelRegistryGetModel: handleModelRegistryGetModel,
     suspend: handleSuspend,
     resume: handleResume,
+    state: handleState,
 };

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

@@ -1,14 +1,40 @@
-import { type DownloadEntry } from "../../../../schemas/index";
-export declare function getActiveDownload(key: string): DownloadEntry | undefined;
-export declare function registerDownload(key: string, entry: DownloadEntry): void;
-export declare function unregisterDownload(key: string): void;
+import type { ModelProgressUpdate } from "../../../../schemas/index";
+import { AbortController } from "bare-abort-controller";
+import type { DownloadHooks } from "./types";
+export interface Subscriber {
+    id: string;
+    onProgress?: ((progress: ModelProgressUpdate) => void) | undefined;
+    settled: boolean;
+    resolve: (path: string) => void;
+    reject: (error: unknown) => void;
+    promise: Promise<string>;
+}
+export interface Transfer {
+    downloadKey: string;
+    abortController: AbortController;
+    subscribers: Map<string, Subscriber>;
+    lastProgress?: ModelProgressUpdate | undefined;
+    downloadPromise?: Promise<string> | undefined;
+    clearCache: boolean;
+    cacheHit?: boolean;
+}
+export interface DownloadContext {
+    broadcastProgress: (progress: ModelProgressUpdate) => void;
+    signal: AbortSignal;
+    shouldClearCache: () => boolean;
+    setCacheHit: (cacheHit: boolean) => void;
+}
+export interface StartOrJoinResult {
+    promise: Promise<string>;
+    joined: boolean;
+    getCacheHit: () => boolean | undefined;
+}
+export declare function startOrJoinDownload(downloadKey: string, startDownload: (ctx: DownloadContext) => Promise<string>, onProgress?: (progress: ModelProgressUpdate) => void): StartOrJoinResult;
+export declare function cancelTransfer(downloadKey: string, clearCache?: boolean): void;
 export declare function createHyperdriveDownloadKey(hyperdriveKey: string, modelFileName: string): string;
 export declare function createHttpDownloadKey(url: string): string;
-export declare function createRegistryDownloadKey(registryPath: string): string;
-export declare function setClearCacheFlag(downloadKey: string, clearCache: boolean): void;
-export declare function shouldClearCache(downloadKey: string): boolean;
-export declare function clearClearCacheFlag(downloadKey: string): void;
-export declare function createCancelFunction(downloadKey: string, clearCache?: boolean): () => void;
+export declare function createRegistryDownloadKey(registrySource: string, registryPath: string): string;
+export declare function applyJoinedDownloadStats(result: StartOrJoinResult, hooks?: DownloadHooks): Promise<string>;
 export declare function cancelAllDownloads(): void;
 export declare function cleanupDownloads(): Promise<void>;
 //# sourceMappingURL=download-manager.d.ts.map

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

@@ -1,16 +1,124 @@
-import {} from "../../../../schemas/index.js";
+import { AbortController } from "bare-abort-controller";
+import { DownloadCancelledError } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
 const logger = getServerLogger();
-const activeDownloads = new Map();
-const clearCacheFlags = new Map();
-export function getActiveDownload(key) {
-    return activeDownloads.get(key);
+const activeTransfers = new Map();
+let nextSubscriberId = 0;
+function createSubscriber(onProgress) {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        id: String(nextSubscriberId++),
+        onProgress,
+        settled: false,
+        resolve,
+        reject,
+        promise,
+    };
+}
+function settleSubscriber(subscriber, result) {
+    if (subscriber.settled)
+        return;
+    subscriber.settled = true;
+    if (result instanceof Error) {
+        subscriber.reject(result);
+    }
+    else {
+        subscriber.resolve(result);
+    }
+}
+function deliverProgress(transfer, subscriber, progress) {
+    if (subscriber.settled || !subscriber.onProgress)
+        return;
+    try {
+        subscriber.onProgress(progress);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.warn("Progress callback threw; detaching subscriber", {
+            downloadKey: transfer.downloadKey,
+            subscriberId: subscriber.id,
+            error,
+        });
+        settleSubscriber(subscriber, error);
+        transfer.subscribers.delete(subscriber.id);
+    }
+}
+function broadcastTransferProgress(transfer, progress) {
+    transfer.lastProgress = progress;
+    for (const sub of Array.from(transfer.subscribers.values())) {
+        deliverProgress(transfer, sub, progress);
+    }
 }
-export function registerDownload(key, entry) {
-    activeDownloads.set(key, entry);
+export function startOrJoinDownload(downloadKey, startDownload, onProgress) {
+    const existing = activeTransfers.get(downloadKey);
+    if (existing && !existing.abortController.signal.aborted) {
+        logger.info(`📥 Reusing existing download for: ${downloadKey}`);
+        const subscriber = createSubscriber(onProgress);
+        existing.subscribers.set(subscriber.id, subscriber);
+        if (existing.lastProgress) {
+            deliverProgress(existing, subscriber, existing.lastProgress);
+        }
+        return {
+            promise: subscriber.promise,
+            joined: true,
+            getCacheHit: () => existing.cacheHit,
+        };
+    }
+    const abortController = new AbortController();
+    const transfer = {
+        downloadKey,
+        abortController,
+        subscribers: new Map(),
+        clearCache: false,
+    };
+    const initialSubscriber = createSubscriber(onProgress);
+    transfer.subscribers.set(initialSubscriber.id, initialSubscriber);
+    activeTransfers.set(downloadKey, transfer);
+    const downloadPromise = startDownload({
+        broadcastProgress: (progress) => {
+            broadcastTransferProgress(transfer, progress);
+        },
+        signal: abortController.signal,
+        shouldClearCache: () => transfer.clearCache,
+        setCacheHit: (cacheHit) => {
+            transfer.cacheHit = cacheHit;
+        },
+    });
+    transfer.downloadPromise = downloadPromise;
+    downloadPromise.then((path) => {
+        for (const sub of transfer.subscribers.values()) {
+            settleSubscriber(sub, path);
+        }
+    }, (error) => {
+        const rejection = error instanceof Error ? error : new Error(String(error));
+        for (const sub of transfer.subscribers.values()) {
+            settleSubscriber(sub, rejection);
+        }
+    }).finally(() => {
+        if (activeTransfers.get(downloadKey) === transfer) {
+            activeTransfers.delete(downloadKey);
+        }
+    });
+    return {
+        promise: initialSubscriber.promise,
+        joined: false,
+        getCacheHit: () => transfer.cacheHit,
+    };
 }
-export function unregisterDownload(key) {
-    activeDownloads.delete(key);
+export function cancelTransfer(downloadKey, clearCache = false) {
+    const transfer = activeTransfers.get(downloadKey);
+    if (!transfer)
+        return;
+    transfer.clearCache = clearCache;
+    transfer.abortController.abort();
+    for (const sub of transfer.subscribers.values()) {
+        settleSubscriber(sub, new DownloadCancelledError());
+    }
 }
 export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {
     return `${hyperdriveKey}:${modelFileName}`;
@@ -18,38 +126,32 @@ export function createHyperdriveDownloadKey(hyperdriveKey, modelFileName) {
 export function createHttpDownloadKey(url) {
     return `http:${url}`;
 }
-export function createRegistryDownloadKey(registryPath) {
-    return `registry:${registryPath}`;
-}
-export function setClearCacheFlag(downloadKey, clearCache) {
-    if (clearCache) {
-        clearCacheFlags.set(downloadKey, true);
-    }
-    else {
-        clearCacheFlags.delete(downloadKey);
-    }
-}
-export function shouldClearCache(downloadKey) {
-    return clearCacheFlags.get(downloadKey) ?? false;
-}
-export function clearClearCacheFlag(downloadKey) {
-    clearCacheFlags.delete(downloadKey);
+export function createRegistryDownloadKey(registrySource, registryPath) {
+    return `registry:${registrySource}:${registryPath}`;
 }
-export function createCancelFunction(downloadKey, clearCache = false) {
-    return () => {
-        const entry = getActiveDownload(downloadKey);
-        if (!entry) {
-            return;
+export function applyJoinedDownloadStats(result, hooks) {
+    if (!result.joined)
+        return result.promise;
+    return result.promise.then((path) => {
+        const cacheHit = result.getCacheHit();
+        if (cacheHit === true) {
+            hooks?.markCacheHit?.();
         }
-        // Set flag for the download handlers to check
-        setClearCacheFlag(downloadKey, clearCache);
-        entry.abortController.abort();
-        unregisterDownload(downloadKey);
-    };
+        else if (cacheHit === false) {
+            hooks?.markCacheMiss?.();
+            hooks?.markSharedTransfer?.();
+        }
+        else {
+            hooks?.markSharedTransfer?.();
+        }
+        return path;
+    });
 }
 export function cancelAllDownloads() {
-    logger.info(`🧹 Cancelling ${activeDownloads.size} active downloads`);
-    Array.from(activeDownloads.keys()).forEach((key) => createCancelFunction(key)());
+    logger.info(`🧹 Cancelling ${activeTransfers.size} active downloads`);
+    for (const key of Array.from(activeTransfers.keys())) {
+        cancelTransfer(key);
+    }
 }
 let isCleaningUp = false;
 export async function cleanupDownloads() {
@@ -57,7 +159,9 @@ export async function cleanupDownloads() {
         return;
     isCleaningUp = true;
     try {
-        const downloadPromises = Array.from(activeDownloads.values()).map((entry) => entry.promise.catch(() => { }));
+        const downloadPromises = Array.from(activeTransfers.values())
+            .filter((t) => t.downloadPromise !== undefined)
+            .map((t) => t.downloadPromise.catch(() => { }));
         cancelAllDownloads();
         if (downloadPromises.length > 0) {
             await Promise.allSettled(downloadPromises);

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

@@ -1,6 +1,7 @@
 import type { ModelProgressUpdate } from "../../../../schemas/index";
-import type { DownloadResult } from "./types";
-export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
-export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string): Promise<DownloadResult>;
-export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void): Promise<DownloadResult>;
+import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from "./types";
+export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
+export declare function mergeDownloadStats(results: ResolveResult[]): DownloadStats | undefined;
 //# sourceMappingURL=download-stats.d.ts.map