@qvac/sdk 0.6.0 → 0.7.0

package/dist/server/rpc/handler-utils.js

@@ -0,0 +1,87 @@
+import { responseSchema, } from "../../schemas/index.js";
+import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
+import { setSDKConfig } from "../bare/registry/config-registry.js";
+import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
+function writeToStream(stream, response) {
+    stream.write(JSON.stringify(responseSchema.parse(response)) + "\n", "utf-8");
+}
+async function executeReplyHandler(req, request, handler) {
+    try {
+        const response = await handler(request);
+        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+    }
+    catch (error) {
+        sendErrorResponse(req, error);
+    }
+}
+async function executeStreamHandler(req, request, handler) {
+    const stream = req.createResponseStream();
+    try {
+        for await (const response of handler(request)) {
+            stream.write(JSON.stringify(responseSchema.parse(response)) + "\n", "utf-8");
+        }
+        stream.end();
+    }
+    catch (error) {
+        sendStreamErrorResponse(stream, error);
+    }
+}
+async function executeProgressHandler(req, request, handler) {
+    const stream = req.createResponseStream();
+    try {
+        const response = await handler(request, (update) => writeToStream(stream, update));
+        writeToStream(stream, response);
+        stream.end();
+    }
+    catch (error) {
+        sendStreamErrorResponse(stream, error);
+    }
+}
+// Unified handler executor with delegation and progress support
+export async function executeHandler(req, request, entry) {
+    const handler = entry.delegatedHandler && entry.isDelegated?.(request)
+        ? entry.delegatedHandler
+        : entry.handler;
+    const wantsProgress = "withProgress" in request &&
+        request.withProgress &&
+        (typeof entry.supportsProgress === "function"
+            ? entry.supportsProgress(request)
+            : entry.supportsProgress);
+    try {
+        if (entry.type === "stream") {
+            await executeStreamHandler(req, request, handler);
+        }
+        else if (wantsProgress) {
+            await executeProgressHandler(req, request, handler);
+        }
+        else {
+            await executeReplyHandler(req, request, handler);
+        }
+    }
+    catch (error) {
+        sendErrorResponse(req, error);
+    }
+}
+export function isInitConfigMessage(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "type" in data &&
+        data.type === "__init_config");
+}
+export function handleInitConfig(req, data) {
+    try {
+        if (data.config) {
+            setSDKConfig(data.config);
+        }
+        if (data.runtimeContext) {
+            setRuntimeContext(data.runtimeContext);
+        }
+        req.reply(JSON.stringify({ success: true }), "utf-8");
+    }
+    catch (error) {
+        req.reply(JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        }), "utf-8");
+    }
+}

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

@@ -1,4 +1,4 @@
-import { cancel } from "../../bare/addons/index.js";
+import { cancel } from "../../bare/ops/cancel.js";
 import { createCancelFunction } from "./load-model/download-manager.js";
 import { cancelRagOperation, DEFAULT_WORKSPACE, } from "../../bare/rag-hyperdb/index.js";
 import { getServerLogger } from "../../../logging/index.js";

package/dist/server/rpc/handlers/completion-stream-delegated.js

@@ -1,6 +1,6 @@
 import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { stream } from "../../../client/rpc/rpc-client.js";
+import { stream } from "../delegate-transport.js";
 import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();

package/dist/server/rpc/handlers/completion-stream.js

@@ -1,45 +1,4 @@
-import { completion } from "../../bare/addons/llamacpp-completion/index.js";
+import { dispatchPluginStream } from "./plugin-dispatch.js";
 export async function* handleCompletionStream(request) {
-    const filteredHistory = request.history.map(({ role, content, attachments }) => ({
-        role,
-        content,
-        attachments: attachments ?? [],
-    }));
-    const stream = completion({
-        history: filteredHistory,
-        modelId: request.modelId,
-        kvCache: request.kvCache,
-        ...(request.tools && { tools: request.tools }),
-    });
-    let stats;
-    let toolCalls = [];
-    let done = false;
-    let buffer = "";
-    while (!done) {
-        const result = await stream.next();
-        if (result.done) {
-            stats = result.value.stats;
-            toolCalls = result.value.toolCalls;
-            done = true;
-        }
-        else {
-            if (request.stream) {
-                yield {
-                    type: "completionStream",
-                    token: result.value.token,
-                    toolCallEvent: result.value.toolCallEvent,
-                };
-            }
-            else {
-                buffer += result.value.token;
-            }
-        }
-    }
-    yield {
-        type: "completionStream",
-        token: request.stream ? "" : buffer,
-        done: true,
-        stats,
-        toolCalls,
-    };
+    yield* dispatchPluginStream(request.modelId, "completionStream", request);
 }

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,4 +1,4 @@
-import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp-completion/index.js";
+import { deleteCache as deleteCacheUtil } from "../../bare/ops/kv-cache-utils.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function handleDeleteCache(request) {

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

@@ -1,23 +1,4 @@
-import { embed } from "../../bare/addons/llamacpp-embedding/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
+import { dispatchPluginReply } from "./plugin-dispatch.js";
 export async function handleEmbed(request) {
-    const { modelId, text } = request;
-    try {
-        const embedding = await embed({ modelId, text });
-        return {
-            type: "embed",
-            success: true,
-            embedding,
-        };
-    }
-    catch (error) {
-        logger.error("Error during embedding:", error);
-        return {
-            type: "embed",
-            success: false,
-            embedding: [],
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
+    return dispatchPluginReply(request.modelId, "embed", request);
 }

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

@@ -1,4 +1,4 @@
-import { models } from "../../../models/hyperdrive/models.js";
+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";
@@ -6,16 +6,16 @@ import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getShardPath } from "../../utils/cache.js";
 import { ModelNotFoundError } from "../../../utils/errors-server.js";
-import { normalizeModelType } from "../../../schemas/model-types.js";
 export async function handleGetModelInfo(request) {
     const { name } = request;
     const catalogEntry = models.find((m) => m.name === name);
     if (!catalogEntry) {
         throw new ModelNotFoundError(`${name}" not found in catalog. Use model names from the catalog (e.g., "WHISPER_TINY", "EMBEDDINGGEMMA_300M_Q4_0")`);
     }
+    const cacheKey = generateShortHash(catalogEntry.registryPath);
     const cacheStatus = catalogEntry.shardMetadata && catalogEntry.shardMetadata.length > 0
-        ? await handleShardedModel(catalogEntry.hyperdriveKey, catalogEntry.shardMetadata)
-        : await handleSingleFileModel(catalogEntry.hyperdriveKey, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
+        ? await handleShardedModel(cacheKey, catalogEntry.shardMetadata)
+        : await handleSingleFileModel(catalogEntry.registryPath, catalogEntry.modelId, catalogEntry.expectedSize, catalogEntry.sha256Checksum);
     const { cacheFiles, isCached, actualSize, cachedAt } = cacheStatus;
     const loadedModelIds = getAllModelIds();
     const loadedInstances = [];
@@ -35,18 +35,21 @@ export async function handleGetModelInfo(request) {
         }
     }
     const isLoaded = loadedInstances.length > 0;
-    // Normalize addon from alias to canonical (vad passes through as-is)
-    const normalizedAddon = catalogEntry.addon === "vad"
-        ? "vad"
-        : normalizeModelType(catalogEntry.addon);
     const modelInfo = {
         name: catalogEntry.name,
         modelId: catalogEntry.modelId,
-        hyperdriveKey: catalogEntry.hyperdriveKey,
-        hyperbeeKey: catalogEntry.hyperbeeKey,
+        registryPath: catalogEntry.registryPath,
+        registrySource: catalogEntry.registrySource,
+        blobCoreKey: catalogEntry.blobCoreKey,
+        blobBlockOffset: catalogEntry.blobBlockOffset,
+        blobBlockLength: catalogEntry.blobBlockLength,
+        blobByteOffset: catalogEntry.blobByteOffset,
+        engine: catalogEntry.engine,
+        quantization: catalogEntry.quantization,
+        params: catalogEntry.params,
         expectedSize: catalogEntry.expectedSize,
         sha256Checksum: catalogEntry.sha256Checksum,
-        addon: normalizedAddon,
+        addon: catalogEntry.addon,
         isCached,
         isLoaded,
         cacheFiles,
@@ -59,13 +62,13 @@ export async function handleGetModelInfo(request) {
         modelInfo,
     };
 }
-async function handleShardedModel(hyperdriveKey, shardMetadata) {
+async function handleShardedModel(cacheKey, shardMetadata) {
     const cacheFiles = [];
     let allShardsCached = true;
     let totalActualSize = 0;
     let latestCachedAt;
     for (const shard of shardMetadata) {
-        const shardPath = getShardPath(hyperdriveKey, shard.filename);
+        const shardPath = getShardPath(cacheKey, shard.filename);
         let shardIsCached = false;
         let shardActualSize;
         let shardCachedAt;
@@ -116,9 +119,10 @@ async function handleShardedModel(hyperdriveKey, shardMetadata) {
     }
     return result;
 }
-async function handleSingleFileModel(hyperdriveKey, modelId, expectedSize, sha256Checksum) {
+async function handleSingleFileModel(registryPath, modelId, expectedSize, sha256Checksum) {
     const cacheDir = getConfiguredCacheDir();
-    const sourceHash = generateShortHash(`${hyperdriveKey}/${modelId}`);
+    // 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;

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

@@ -14,7 +14,11 @@ import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
 import { handleGetModelInfo } from "./get-model-info";
 import { handleOCRStream } from "./ocr-stream";
+import { handlePing } from "./ping";
+import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
+import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
 export declare const handlers: {
+    ping: typeof handlePing;
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
     deleteCache: typeof handleDeleteCache;
@@ -31,5 +35,10 @@ export declare const handlers: {
     textToSpeech: typeof handleTextToSpeech;
     getModelInfo: typeof handleGetModelInfo;
     ocrStream: typeof handleOCRStream;
+    pluginInvoke: typeof handlePluginInvoke;
+    pluginInvokeStream: typeof handlePluginInvokeStream;
+    modelRegistryList: typeof handleModelRegistryList;
+    modelRegistrySearch: typeof handleModelRegistrySearch;
+    modelRegistryGetModel: typeof handleModelRegistryGetModel;
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -14,7 +14,11 @@ import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
 import { handleGetModelInfo } from "./get-model-info.js";
 import { handleOCRStream } from "./ocr-stream.js";
+import { handlePing } from "./ping.js";
+import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js";
+import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
 export const handlers = {
+    ping: handlePing,
     completionStream: handleCompletionStream,
     downloadAsset: handleDownloadAsset,
     deleteCache: handleDeleteCache,
@@ -31,4 +35,9 @@ export const handlers = {
     textToSpeech: handleTextToSpeech,
     getModelInfo: handleGetModelInfo,
     ocrStream: handleOCRStream,
+    pluginInvoke: handlePluginInvoke,
+    pluginInvokeStream: handlePluginInvokeStream,
+    modelRegistryList: handleModelRegistryList,
+    modelRegistrySearch: handleModelRegistrySearch,
+    modelRegistryGetModel: handleModelRegistryGetModel,
 };

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

@@ -4,6 +4,7 @@ export declare function registerDownload(key: string, entry: DownloadEntry): voi
 export declare function unregisterDownload(key: string): 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;

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

@@ -18,6 +18,9 @@ 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);

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

@@ -1,11 +1,13 @@
 import { normalizeModelType, ModelType } from "../../../../schemas/index.js";
 import { hyperdriveUrlSchema } from "../../../../schemas/load-model.js";
-import { loadModel } from "../../../bare/addons/index.js";
+import { loadModel } from "../../../bare/ops/load-model.js";
 import { resolveModelPath } from "./resolve.js";
 import { getModelEntry, updateModelConfig, } from "../../../bare/registry/model-registry.js";
 import { generateShortHash, transformConfigForReload } from "../../../utils/index.js";
-import { TTSConfigModelRequiredError, ESpeakDataPathRequiredError, ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../../utils/errors-server.js";
+import { ConfigReloadNotSupportedError, ModelTypeMismatchError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../logging/index.js";
+import { OCR_CRAFT_DETECTOR } from "../../../../models/registry/index.js";
+import { getPlugin } from "../../../plugins/index.js";
 const logger = getServerLogger();
 const OCR_DETECTOR_FILENAME = "detector_craft.onnx";
 export async function handleLoadModel(request, progressCallback) {
@@ -14,7 +16,7 @@ export async function handleLoadModel(request, progressCallback) {
         return handleConfigReload(request);
     }
     // Handle load new model from source
-    const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc, configSrc, } = request;
+    const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc } = request;
     const canonicalModelType = normalizeModelType(request.modelType);
     const srcVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
         ? request.srcVocabSrc
@@ -22,9 +24,6 @@ export async function handleLoadModel(request, progressCallback) {
     const dstVocabSrc = canonicalModelType === ModelType.nmtcppTranslation
         ? request.dstVocabSrc
         : undefined;
-    const eSpeakDataPath = canonicalModelType === ModelType.onnxTts
-        ? request.eSpeakDataPath
-        : undefined;
     const detectorModelSrc = canonicalModelType === ModelType.onnxOcr
         ? request.detectorModelSrc
         : undefined;
@@ -38,11 +37,7 @@ export async function handleLoadModel(request, progressCallback) {
         if (vadModelSrc) {
             vadModelPath = await resolveModelPath(vadModelSrc, progressCallback, seed);
         }
-        let ttsConfigModelPath;
-        if (configSrc) {
-            ttsConfigModelPath = await resolveModelPath(configSrc, progressCallback, seed);
-        }
-        // For OCR models: use provided detectorModelSrc or auto-derive from same hyperdrive key
+        // For OCR models: use provided detectorModelSrc or auto-derive
         let detectorModelPath;
         if (canonicalModelType === ModelType.onnxOcr) {
             if (detectorModelSrc) {
@@ -53,13 +48,9 @@ export async function handleLoadModel(request, progressCallback) {
                 const derivedDetectorSrc = `pear://${key}/${OCR_DETECTOR_FILENAME}`;
                 detectorModelPath = await resolveModelPath(derivedDetectorSrc, progressCallback, seed);
             }
-        }
-        // For TTS models, ttsConfigModelPath and eSpeakDataPath are required
-        if (canonicalModelType === ModelType.onnxTts && !ttsConfigModelPath) {
-            throw new TTSConfigModelRequiredError();
-        }
-        if (canonicalModelType === ModelType.onnxTts && !eSpeakDataPath) {
-            throw new ESpeakDataPathRequiredError();
+            else if (modelSrc.startsWith("registry://")) {
+                detectorModelPath = await resolveModelPath(OCR_CRAFT_DETECTOR, progressCallback, seed);
+            }
         }
         // For Bergamot models, resolve vocabulary sources to local paths
         if (canonicalModelType === ModelType.nmtcppTranslation &&
@@ -68,8 +59,12 @@ export async function handleLoadModel(request, progressCallback) {
             if (nmtConfig.engine === "Bergamot") {
                 let resolvedSrcVocabSrc = srcVocabSrc;
                 let resolvedDstVocabSrc = dstVocabSrc;
-                if ((!srcVocabSrc || !dstVocabSrc) && modelSrc.startsWith("pear://")) {
-                    const derivedVocabSrcs = deriveBergamotVocabSources(modelSrc);
+                if (!srcVocabSrc || !dstVocabSrc) {
+                    const derivedVocabSrcs = modelSrc.startsWith("pear://")
+                        ? deriveBergamotVocabSources(modelSrc)
+                        : modelSrc.startsWith("registry://")
+                            ? deriveBergamotRegistryVocabSources(modelSrc)
+                            : null;
                     if (derivedVocabSrcs) {
                         resolvedSrcVocabSrc = srcVocabSrc ?? derivedVocabSrcs.srcVocabSrc;
                         resolvedDstVocabSrc = dstVocabSrc ?? derivedVocabSrcs.dstVocabSrc;
@@ -83,18 +78,27 @@ export async function handleLoadModel(request, progressCallback) {
                 }
             }
         }
-        // Generate hash-based modelId
+        // Use plugin's resolveConfig hook if available to resolve model sources
+        let resolvedModelConfig = request.modelConfig;
+        const plugin = getPlugin(canonicalModelType);
+        if (plugin?.resolveConfig && resolvedModelConfig) {
+            const resolve = (src) => resolveModelPath(src, progressCallback, seed);
+            resolvedModelConfig = await plugin.resolveConfig(resolvedModelConfig, resolve);
+        }
+        // Generate hash-based modelId from modelConfig (includes all sources for TTS)
         const configStr = JSON.stringify(request.modelConfig, Object.keys(request.modelConfig).sort());
         const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
         const modelId = generateShortHash(modelHashInput);
+        const loadModelOptions = {
+            ...request,
+            modelConfig: resolvedModelConfig,
+        };
         await loadModel({
             modelId,
             modelPath,
-            options: request,
+            options: loadModelOptions,
             projectionModelPath,
             vadModelPath,
-            ttsConfigModelPath,
-            eSpeakDataPath,
             detectorModelPath,
             modelName,
         });
@@ -177,3 +181,22 @@ function deriveBergamotVocabSources(modelSrc) {
         dstVocabSrc: sharedVocab,
     };
 }
+function deriveBergamotRegistryVocabSources(modelSrc) {
+    // registry://s3/path/to/model.enfr.intgemm.alphas.bin
+    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match || !match[1] || !match[2])
+        return null;
+    const basePath = match[1];
+    const langPair = match[2];
+    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
+        return {
+            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
+            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+        };
+    }
+    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
+    return {
+        srcVocabSrc: sharedVocab,
+        dstVocabSrc: sharedVocab,
+    };
+}

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

@@ -4,7 +4,7 @@ import { Readable } from "bare-stream";
 import fetch from "bare-fetch";
 import { AbortController } from "bare-abort-controller";
 import { withTimeout } from "../../../../utils/withTimeout.js";
-import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
+import { getModelsCacheDir, getShardedModelCacheDir, generateShortHash, detectShardedModel, parsePatternBasedShardUrl, extractTensorsFromShards, calculatePercentage, isArchiveUrl, sanitizePathComponent, extractAndValidateShardedArchive, validateShardedModelCache, checkAllShardsExist, generateShardFilenames, hasValidGGUFHeader, } from "../../../utils/index.js";
 import { getSDKConfig } from "../../../bare/registry/config-registry.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHttpDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
 import { DownloadCancelledError, HTTPError, NoResponseBodyError, PartialDownloadOfflineError, ResponseBodyNotReadableError, } from "../../../../utils/errors-server.js";
@@ -18,7 +18,8 @@ function extractFilenameFromUrl(url) {
     const filename = urlParts[urlParts.length - 1] || "model.gguf";
     // Remove query parameters if present
     const cleanFilename = filename.split("?")[0] || "model.gguf";
-    return cleanFilename;
+    // Sanitize to prevent path traversal via crafted URLs
+    return sanitizePathComponent(cleanFilename);
 }
 async function validateCachedFile(modelPath, url, signal) {
     try {

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

@@ -5,9 +5,9 @@ import Hyperswarm, {} from "hyperswarm";
 import Hyperdrive from "hyperdrive";
 import {} from "bare-stream";
 import { AbortController } from "bare-abort-controller";
-import { getEnv } from "../../../worker.js";
+import { getEnv } from "../../../env.js";
 import { getModelsCacheDir, generateShortHash, detectShardedModel, getShardedModelCacheDir, getShardPath, checkShardCompleteness, calculateFileChecksum, extractTensorsFromShards, calculatePercentage, } from "../../../utils/index.js";
-import { getModelBySrc } from "../../../../models/hyperdrive/index.js";
+import { getModelBySrc } from "../../../../models/registry/index.js";
 import { getActiveDownload, registerDownload, unregisterDownload, createHyperdriveDownloadKey, shouldClearCache, clearClearCacheFlag, } from "./download-manager.js";
 import { getSDKConfig } from "../../../bare/registry/config-registry.js";
 import { FileNotFoundError, ChecksumValidationFailedError, DownloadCancelledError, HyperdriveDownloadFailedError, ModelLoadFailedError, NoBlobFoundError, } from "../../../../utils/errors-server.js";
@@ -185,6 +185,7 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
         });
     };
     signal?.addEventListener("abort", cleanup);
+    let downloadSucceeded = false;
     try {
         const progressContext = progressCallback
             ? {
@@ -211,10 +212,7 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
                 // Ignore stat errors
             }
         }
-        // Delete corestore directory after successful download (only when not seeding, to save space)
-        if (!seed) {
-            await deleteCorestoreDirectory(setup.corestoreDir);
-        }
+        downloadSucceeded = true;
     }
     catch (error) {
         logger.error("❌ Error during hyperdrive download:", error instanceof Error ? error.message : String(error));
@@ -228,6 +226,10 @@ async function downloadSingleFileToFilesystem(modelPath, modelFileName, hyperdri
         signal?.removeEventListener("abort", cleanup);
         if (!seed) {
             await cleanupHyperdrive(setup);
+            // Delete only after close - Windows EBUSY on LOCK if deleted before corestore.close()
+            if (downloadSucceeded) {
+                await deleteCorestoreDirectory(corestoreDir);
+            }
         }
         // Only delete corestore and partial file if user explicitly requested clearCache
         if (signal?.aborted && shouldClearCache(downloadKey)) {
@@ -409,6 +411,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
         });
     };
     signal?.addEventListener("abort", cleanup);
+    let downloadSucceeded = false;
     try {
         // Calculate overall progress
         const overallTotal = shardMetadata.reduce((sum, shard) => sum + shard.expectedSize, 0);
@@ -485,10 +488,7 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
             });
         }
         await extractTensorsFromShards(shardDir, firstShardFileName);
-        // Delete corestore directory after successful download (only when not seeding)
-        if (!seed) {
-            await deleteCorestoreDirectory(corestoreDir);
-        }
+        downloadSucceeded = true;
     }
     catch (error) {
         logger.error("❌ Error during sharded hyperdrive download:", error instanceof Error ? error.message : String(error));
@@ -502,6 +502,10 @@ async function downloadShardedFilesToFilesystem(hyperdriveKey, firstShardFileNam
         signal?.removeEventListener("abort", cleanup);
         if (!seed) {
             await cleanupHyperdrive(setup);
+            // Delete only after close - Windows EBUSY on LOCK if deleted before corestore.close()
+            if (downloadSucceeded) {
+                await deleteCorestoreDirectory(corestoreDir);
+            }
         }
         // Only delete corestore and partial files if user explicitly requested clearCache
         const downloadKey = createHyperdriveDownloadKey(hyperdriveKey, firstShardFileName);

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

@@ -0,0 +1,10 @@
+import type { ModelProgressUpdate } from "../../../../schemas/index";
+/**
+ * Download a model from the QVAC Registry.
+ *
+ * For known models (present in models.ts), uses direct blob download which
+ * skips the registry metadata sync entirely. Falls back to metadata-based
+ * download for unknown models.
+ */
+export declare function downloadModelFromRegistry(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string): Promise<string>;
+//# sourceMappingURL=registry.d.ts.map