@qvac/sdk 0.9.1 → 0.10.0

package/dist/server/worker-core.js

@@ -9,10 +9,43 @@ import { closeRegistryClient } from "./bare/registry/registry-client.js";
 import { clearAllLoggingStreams, startLogBuffering, } from "./bare/registry/logging-stream-registry.js";
 import { clearAllAddonLoggers, getServerLogger, SDK_LOG_ID } from "../logging/index.js";
 import { clearPlugins } from "./plugins/index.js";
+import { acquireWorkerLock, releaseWorkerLock, } from "./utils/worker-lock.js";
 let coreInitialized = false;
 let rpcInitialized = false;
+// Set true when the cleanup body has run at least once. Lets both
+// cleanupForTerminate (pre-terminate path) and shutdownBareDirectWorker
+// (signal/exit path) call runCleanup() without doing duplicate work.
+let cleanupRan = false;
+// Set true when shutdownBareDirectWorker is in flight. Distinct from
+// cleanupRan: cleanupForTerminate must NOT set this, otherwise a later
+// SIGTERM/SIGINT/uncaught-exception would early-return at the guard
+// in shutdownBareDirectWorker and skip releaseWorkerLock + process.exit.
 let isShuttingDown = false;
 const logger = getServerLogger();
+// Defense-in-depth grace period for the SIGKILL safety net armed before
+// process.exit() in shutdownBareDirectWorker. If process.exit cannot
+// terminate the worker within this window — typically because some path
+// holds a non-cancellable native handle (e.g. a libuv worker thread
+// blocked on flock; see QVAC-18197) — we force-kill the OS process to
+// guarantee bounded shutdown time.
+const FORCE_EXIT_GRACE_MS = 3_000;
+function scheduleForceExit() {
+    const timer = setTimeout(() => {
+        logger.error(`process.exit did not terminate the worker within ${FORCE_EXIT_GRACE_MS}ms — ` +
+            `force-killing self (likely blocked native handle)`);
+        try {
+            process.kill(process.pid, "SIGKILL");
+        }
+        catch {
+            // best-effort — if SIGKILL itself fails, there's nothing more to do
+        }
+    }, FORCE_EXIT_GRACE_MS);
+    // Don't let the safety-net timer keep the process alive on the happy
+    // path. Bare returns an object (not a number) from setTimeout.
+    if (timer && typeof timer === "object" && "unref" in timer) {
+        timer.unref();
+    }
+}
 export function initializeWorkerCore() {
     if (coreInitialized) {
         const validatedEnv = getValidatedEnv();
@@ -20,6 +53,7 @@ export function initializeWorkerCore() {
     }
     startLogBuffering(SDK_LOG_ID);
     const { hasRPCConfig } = initEnv();
+    acquireWorkerLock();
     setupShutdownHandlers();
     coreInitialized = true;
     logger.debug("Worker core initialized");
@@ -37,7 +71,9 @@ export function ensureRPCSetup() {
         const ipcSocketPath = validatedEnv.QVAC_IPC_SOCKET_PATH;
         if (ipcSocketPath) {
             logger.info(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
-            const rpc = createIPCClient(ipcSocketPath);
+            const rpc = createIPCClient(ipcSocketPath, {
+                onDisconnect: () => void shutdownBareDirectWorker("ipc-disconnect"),
+            });
             logger.debug("Desktop IPC client created?", !!rpc);
         }
         else {
@@ -61,31 +97,95 @@ function clearRegistries() {
     clearAllAddonLoggers();
     clearPlugins();
 }
+/**
+ * Run the cleanup body shared by terminal and graceful-shutdown paths.
+ * Clears plugin registries (which calls each addon's `releaseLogger` →
+ * frees env-bound js_ref_t state), unloads all loaded models (which calls
+ * each addon's `destroyInstance`), and closes infra (swarm, rag, downloads,
+ * registry client). Does NOT touch the worker lock or call `process.exit`.
+ *
+ * Idempotent: subsequent calls are no-ops via the `cleanupRan` flag. The
+ * underlying clearPlugins / unloadAllModels / closers are also idempotent
+ * on empty registries, but the flag avoids the redundant log noise and
+ * allocator churn.
+ */
+async function runCleanup() {
+    if (cleanupRan)
+        return;
+    cleanupRan = true;
+    clearRegistries();
+    await Promise.allSettled([
+        destroySwarm(),
+        closeAllRagInstances(),
+        cleanupDownloads(),
+        unloadAllModels(),
+        closeRegistryClient(),
+    ]);
+}
+/**
+ * Pre-terminate cleanup, callable while the worker is still alive.
+ *
+ * On platforms where the worker lives in the same OS process as the JS host
+ * (i.e. mobile via react-native-bare-kit Worklet), `process.exit()` would
+ * kill the entire app. This path runs the same registry/model cleanup as
+ * `shutdownBareDirectWorker` but skips the lock release + exit, leaving the
+ * caller (typically the SDK client about to call `worklet.terminate()`)
+ * responsible for tearing the worker down.
+ *
+ * Critical for clean termination: addons hold static state with js_ref_t
+ * handles into the current V8 isolate; without this cleanup, those refs
+ * survive into the next worklet's isolate and crash on first access.
+ */
+export async function cleanupForTerminate() {
+    // Intentionally does NOT set isShuttingDown — that flag is reserved for
+    // shutdownBareDirectWorker so a later SIGTERM/SIGINT still gets to run
+    // the lock release + process.exit path. runCleanup is idempotent on its
+    // own, so a follow-up shutdownBareDirectWorker call won't redo the body.
+    if (cleanupRan)
+        return;
+    logger.info("🧹 Pre-terminate cleanup starting...");
+    try {
+        await runCleanup();
+        logger.info("✅ Pre-terminate cleanup completed");
+    }
+    catch (error) {
+        logger.error("❌ Error during pre-terminate cleanup:", error);
+    }
+}
 export async function shutdownBareDirectWorker(reason) {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
-    const message = reason === "signal"
-        ? "🐻 Bare worker shutdown signal received, cleaning up..."
-        : "🧹 Bare direct mode RPC closed, cleaning up...";
-    logger.info(message);
+    const messages = {
+        signal: "🐻 Bare worker shutdown signal received, cleaning up...",
+        "rpc-close": "🧹 Bare direct mode RPC closed, cleaning up...",
+        "uncaught-exception": "💥 Uncaught exception, cleaning up...",
+        "unhandled-rejection": "💥 Unhandled rejection, cleaning up...",
+        "ipc-disconnect": "🔌 Parent IPC disconnected, cleaning up...",
+    };
+    logger.info(messages[reason]);
     try {
-        clearRegistries();
-        await Promise.allSettled([
-            destroySwarm(),
-            closeAllRagInstances(),
-            cleanupDownloads(),
-            unloadAllModels(),
-            closeRegistryClient(),
-        ]);
+        // Idempotent: if cleanupForTerminate already ran, this is a no-op.
+        await runCleanup();
         logger.info("✅ Cleanup completed successfully");
     }
     catch (error) {
         logger.error("❌ Error during shutdown cleanup:", error);
     }
-    process.exit(0);
+    releaseWorkerLock();
+    scheduleForceExit();
+    const isGraceful = reason === "signal" || reason === "rpc-close";
+    process.exit(isGraceful ? 0 : 1);
 }
 function setupShutdownHandlers() {
     process.once("SIGTERM", () => void shutdownBareDirectWorker("signal"));
     process.once("SIGINT", () => void shutdownBareDirectWorker("signal"));
+    process.on("uncaughtException", (err) => {
+        logger.error("Uncaught exception in worker:", err);
+        void shutdownBareDirectWorker("uncaught-exception");
+    });
+    process.on("unhandledRejection", (reason) => {
+        logger.error("Unhandled rejection in worker:", reason);
+        void shutdownBareDirectWorker("unhandled-rejection");
+    });
 }

package/dist/utils/aggregate-events.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, ToolCall } from "../schemas/index";
+import { type ToolHandlerMap } from "./tool-helpers";
+export type AggregatedEvents = {
+    contentText: string;
+    thinkingText: string;
+    stats: CompletionStats | undefined;
+    toolCalls: ToolCall[];
+    rawFullText: string | undefined;
+    error: CompletionError | undefined;
+};
+export declare function aggregateEvents(events: CompletionEvent[]): AggregatedEvents;
+export declare function buildFinalFromEvents(events: CompletionEvent[], handlers: ToolHandlerMap): {
+    final: CompletionFinal;
+    error: CompletionError | undefined;
+};
+//# sourceMappingURL=aggregate-events.d.ts.map

package/dist/utils/aggregate-events.js

@@ -0,0 +1,52 @@
+import { normalizeAssistantCacheContent } from "./cache-normalize.js";
+import { attachHandlersToToolCalls, } from "./tool-helpers.js";
+export function aggregateEvents(events) {
+    let contentText = "";
+    let thinkingText = "";
+    let stats;
+    let rawFullText;
+    let error;
+    const toolCalls = [];
+    for (const event of events) {
+        if (event.type === "contentDelta") {
+            contentText += event.text;
+        }
+        else if (event.type === "thinkingDelta") {
+            thinkingText += event.text;
+        }
+        else if (event.type === "completionStats") {
+            stats = event.stats;
+        }
+        else if (event.type === "toolCall") {
+            toolCalls.push(event.call);
+        }
+        else if (event.type === "completionDone") {
+            if ("raw" in event && event.raw) {
+                rawFullText = event.raw.fullText;
+            }
+            if (event.stopReason === "error" && "error" in event) {
+                error = event.error;
+            }
+        }
+    }
+    return { contentText, thinkingText, stats, toolCalls, rawFullText, error };
+}
+export function buildFinalFromEvents(events, handlers) {
+    const { contentText, thinkingText, stats, toolCalls, rawFullText, error } = aggregateEvents(events);
+    const attachedToolCalls = attachHandlersToToolCalls(toolCalls, handlers);
+    const fullText = rawFullText ?? contentText;
+    const cacheableAssistantContent = attachedToolCalls.length === 0
+        ? normalizeAssistantCacheContent(fullText)
+        : undefined;
+    const final = {
+        contentText,
+        ...(thinkingText && { thinkingText }),
+        toolCalls: attachedToolCalls,
+        ...(stats && { stats }),
+        raw: { fullText },
+        ...(cacheableAssistantContent !== undefined && {
+            cacheableAssistantContent,
+        }),
+    };
+    return { final, error };
+}

package/dist/utils/cache-normalize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonicalize assistant message text for the auto-cache key.
+ *
+ * The server saves raw stream text (with think tags when `captureThinking` is
+ * on), while `final.contentText` only aggregates `contentDelta` events.
+ * Stripping think blocks (paired and unclosed-trailing) and trimming lets
+ * callers push back either shape and still hit the cache.
+ */
+export declare function normalizeAssistantCacheContent(content: string): string;
+//# sourceMappingURL=cache-normalize.d.ts.map

package/dist/utils/cache-normalize.js

@@ -0,0 +1,23 @@
+// Shared by the auto-cache writer and reader on the server, and surfaced to
+// clients as `final.cacheableAssistantContent` so the next turn's `history`
+// produces a stable cache key.
+// Case-insensitive in case a model variant emits `<Think>`; the addon uses
+// lowercase today but we don't want a casing change to regress hit-rate.
+const THINK_BLOCK_RE = /<think>[\s\S]*?<\/think>/gi;
+// Trailing unclosed `<think>...` when a stop token interrupts mid-thought.
+// Must run after THINK_BLOCK_RE so only a genuinely unclosed tail matches.
+const UNCLOSED_TRAILING_THINK_RE = /<think>[\s\S]*$/i;
+/**
+ * Canonicalize assistant message text for the auto-cache key.
+ *
+ * The server saves raw stream text (with think tags when `captureThinking` is
+ * on), while `final.contentText` only aggregates `contentDelta` events.
+ * Stripping think blocks (paired and unclosed-trailing) and trimming lets
+ * callers push back either shape and still hit the cache.
+ */
+export function normalizeAssistantCacheContent(content) {
+    return content
+        .replace(THINK_BLOCK_RE, "")
+        .replace(UNCLOSED_TRAILING_THINK_RE, "")
+        .trim();
+}

package/dist/utils/encoding.d.ts

@@ -6,4 +6,12 @@
  * provides a cross-platform alternative to Buffer.from(str, "base64").
  */
 export declare function decodeBase64(base64: string): Uint8Array;
+/**
+ * Encodes a Uint8Array to a base64 string.
+ *
+ * Uses btoa which is available across all runtimes (Node, Bare, React Native).
+ * Buffer is not globally available in React Native (Hermes engine), so this
+ * provides a cross-platform alternative to Buffer.from(bytes).toString("base64").
+ */
+export declare function encodeBase64(bytes: Uint8Array): string;
 //# sourceMappingURL=encoding.d.ts.map

package/dist/utils/encoding.js

@@ -12,3 +12,16 @@ export function decodeBase64(base64) {
         bytes[i] = binary.charCodeAt(i);
     return bytes;
 }
+/**
+ * Encodes a Uint8Array to a base64 string.
+ *
+ * Uses btoa which is available across all runtimes (Node, Bare, React Native).
+ * Buffer is not globally available in React Native (Hermes engine), so this
+ * provides a cross-platform alternative to Buffer.from(bytes).toString("base64").
+ */
+export function encodeBase64(bytes) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}

package/dist/utils/errors-client.d.ts

@@ -20,6 +20,12 @@ export declare class InvalidToolSchemaError extends QvacErrorBase {
 export declare class OCRFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class ModelTypeRequiredError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class ModelSrcTypeMismatchError extends QvacErrorBase {
+    constructor(inferred: string, resolved: string, cause?: unknown);
+}
 export declare class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType: string, cause?: unknown);
 }
@@ -32,6 +38,9 @@ export declare class RPCResponseStreamNotCreatedError extends QvacErrorBase {
 export declare class RPCConnectionFailedError extends QvacErrorBase {
     constructor(details: string, cause?: unknown);
 }
+export declare class RPCInitTimeoutError extends QvacErrorBase {
+    constructor(timeoutMs: number, cause?: unknown);
+}
 export declare class ProviderStartFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -80,6 +89,9 @@ export declare class EmbedFailedError extends QvacErrorBase {
 export declare class TranscriptionFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class TranslationFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -38,6 +38,16 @@ export class OCRFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class ModelTypeRequiredError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.MODEL_TYPE_REQUIRED, undefined, cause));
+    }
+}
+export class ModelSrcTypeMismatchError extends QvacErrorBase {
+    constructor(inferred, resolved, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.MODEL_SRC_TYPE_MISMATCH, [inferred, resolved], cause));
+    }
+}
 // ============== RPC Communication Errors ==============
 export class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType, cause) {
@@ -59,6 +69,11 @@ export class RPCConnectionFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_CONNECTION_FAILED, [details], cause));
     }
 }
+export class RPCInitTimeoutError extends QvacErrorBase {
+    constructor(timeoutMs, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_INIT_TIMEOUT, [timeoutMs], cause));
+    }
+}
 // ============== Provider/Delegation Errors ==============
 export class ProviderStartFailedError extends QvacErrorBase {
     constructor(details, cause) {
@@ -144,6 +159,11 @@ export class TranscriptionFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSCRIPTION_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_STREAM_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class TranslationFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSLATION_FAILED, details ? [details] : undefined, cause));

package/dist/utils/errors-server.d.ts

@@ -68,12 +68,23 @@ export declare class CancelFailedError extends QvacErrorBase {
 export declare class TextToSpeechFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class ConfigReloadNotSupportedError extends QvacErrorBase {
     constructor(modelId: string, cause?: unknown);
 }
 export declare class ModelTypeMismatchError extends QvacErrorBase {
     constructor(expectedType: string, providedType: string, cause?: unknown);
 }
+export declare class ModelOperationNotSupportedError extends QvacErrorBase {
+    readonly modelId: string;
+    readonly modelType: string;
+    readonly operation: string;
+    readonly supportedOperations: readonly string[];
+    readonly suggestedModelTypes: readonly string[];
+    constructor(modelId: string, modelType: string, operation: string, supportedOperations: readonly string[], suggestedModelTypes: readonly string[], cause?: unknown);
+}
 export declare class OCRFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -233,6 +244,9 @@ export declare class LifecycleSuspendFailedError extends QvacErrorBase {
 export declare class LifecycleResumeFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class LifecycleOperationBlockedError extends QvacErrorBase {
+    constructor(requestType: string, lifecycleState: string);
+}
 export declare class PathTraversalError extends QvacErrorBase {
     constructor(component: string, basePath: string, cause?: unknown);
 }

package/dist/utils/errors-server.js

@@ -120,6 +120,11 @@ export class TextToSpeechFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_STREAM_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class ConfigReloadNotSupportedError extends QvacErrorBase {
     constructor(modelId, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONFIG_RELOAD_NOT_SUPPORTED, [modelId], cause));
@@ -130,6 +135,27 @@ export class ModelTypeMismatchError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_TYPE_MISMATCH, [expectedType, providedType], cause));
     }
 }
+export class ModelOperationNotSupportedError extends QvacErrorBase {
+    modelId;
+    modelType;
+    operation;
+    supportedOperations;
+    suggestedModelTypes;
+    constructor(modelId, modelType, operation, supportedOperations, suggestedModelTypes, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_OPERATION_NOT_SUPPORTED, [
+            modelId,
+            modelType,
+            operation,
+            supportedOperations.join(", "),
+            suggestedModelTypes.join(", "),
+        ], cause));
+        this.modelId = modelId;
+        this.modelType = modelType;
+        this.operation = operation;
+        this.supportedOperations = supportedOperations;
+        this.suggestedModelTypes = suggestedModelTypes;
+    }
+}
 export class OCRFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
@@ -407,6 +433,11 @@ export class LifecycleResumeFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.LIFECYCLE_RESUME_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class LifecycleOperationBlockedError extends QvacErrorBase {
+    constructor(requestType, lifecycleState) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LIFECYCLE_OPERATION_BLOCKED, [requestType, lifecycleState]));
+    }
+}
 // ============== Security Errors ==============
 export class PathTraversalError extends QvacErrorBase {
     constructor(component, basePath, cause) {

package/dist/utils/load-model-validation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Throws {@link ModelSrcTypeMismatchError} when explicit
+ * `modelType` disagrees with the type inferred from `modelSrc`.
+ * No-op when nothing can be inferred.
+ */
+export declare function assertModelSrcMatchesModelType(modelSrc: unknown, explicitModelType: string): void;
+//# sourceMappingURL=load-model-validation.d.ts.map

package/dist/utils/load-model-validation.js

@@ -0,0 +1,18 @@
+import { inferModelTypeFromModelSrc } from "../schemas/model-src-utils.js";
+import { normalizeModelType } from "../schemas/model-types.js";
+import { ModelSrcTypeMismatchError } from "./errors-client.js";
+/**
+ * Throws {@link ModelSrcTypeMismatchError} when explicit
+ * `modelType` disagrees with the type inferred from `modelSrc`.
+ * No-op when nothing can be inferred.
+ */
+export function assertModelSrcMatchesModelType(modelSrc, explicitModelType) {
+    const inferred = inferModelTypeFromModelSrc(modelSrc);
+    if (!inferred)
+        return;
+    const normalizedInferred = normalizeModelType(inferred);
+    const normalizedExplicit = normalizeModelType(explicitModelType);
+    if (normalizedInferred !== normalizedExplicit) {
+        throw new ModelSrcTypeMismatchError(normalizedInferred, normalizedExplicit);
+    }
+}

package/expo/plugins/patches/android-link.mjs

@@ -54,7 +54,7 @@ if (fs.existsSync(manifestPath)) {
 for await (const resource of link(
   projectRoot,
   {
-    target: ["android-arm64", "android-arm", "android-ia32", "android-x64"],
+    hosts: ["android-arm64", "android-arm", "android-ia32", "android-x64"],
     out: addonsDir,
   },
   pkg,

package/expo/plugins/patches/ios-link.mjs

@@ -54,7 +54,7 @@ if (fs.existsSync(manifestPath)) {
 for await (const resource of link(
   projectRoot,
   {
-    target: ["ios-arm64", "ios-arm64-simulator", "ios-x64-simulator"],
+    hosts: ["ios-arm64", "ios-arm64-simulator", "ios-x64-simulator"],
     out: addonsDir,
   },
   pkg,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -173,30 +173,29 @@
   },
   "dependencies": {
     "@qvac/decoder-audio": "^0.3.7",
-    "@qvac/diffusion-cpp": "^0.1.3",
-    "@qvac/dl-filesystem": "^0.2.1",
-    "@qvac/embed-llamacpp": "^0.13.4",
+    "@qvac/diffusion-cpp": "^0.3.0",
+    "@qvac/embed-llamacpp": "^0.14.0",
     "@qvac/error": "^0.1.1",
     "@qvac/langdetect-text": "^0.1.2",
-    "@qvac/llm-llamacpp": "^0.14.4",
+    "@qvac/llm-llamacpp": "^0.17.1",
     "@qvac/logging": "^0.1.0",
     "@qvac/ocr-onnx": "^0.4.2",
     "@qvac/rag": "^0.4.4",
-    "@qvac/registry-client": "^0.4.0",
+    "@qvac/registry-client": "^0.4.1",
     "@qvac/transcription-parakeet": "^0.3.1",
     "@qvac/transcription-whispercpp": "^0.6.1",
-    "@qvac/translation-nmtcpp": "^0.6.10",
-    "@qvac/tts-onnx": "^0.8.2",
+    "@qvac/translation-nmtcpp": "^2.0.1",
+    "@qvac/tts-onnx": "^0.8.4",
     "fast-safe-stringify": "2.1.1",
     "which-runtime": "^1.3.2",
-    "zod": "^4.0.17"
+    "zod": "^4.3.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.33.0",
     "@expo/config-plugins": "^54.0.4",
     "@lancedb/lancedb": "^0.21.3",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@qvac/cli": "^0.2.3",
+    "@qvac/cli": "^0.2.4",
     "@sqliteai/sqlite-wasm": "3.50.4-sync.0.8.30-vector.0.9.23",
     "@types/node": "^24.2.1",
     "@types/tar-stream": "^3.1.4",
@@ -216,7 +215,7 @@
     "hyperdb": "^4.16.1",
     "pear-pipe": "^1.0.6",
     "prettier": "^3.6.2",
-    "react-native-bare-kit": "^0.11.5",
+    "react-native-bare-kit": "0.12.3",
     "remark-cli": "^12.0.1",
     "remark-code-import": "^1.2.0",
     "remark-frontmatter": "^5.0.0",
@@ -227,16 +226,16 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@qvac/cli": "^0.2.3",
+    "@qvac/cli": "^0.2.4",
     "bare-abort-controller": "^1.0.0",
     "bare-buffer": "^3.4.2",
     "bare-crypto": "^1.13.4",
     "bare-dns": "^2.1.4",
     "bare-fetch": "^2.5.1",
-    "bare-fs": "^4.5.2",
+    "bare-fs": "^4.5.1",
     "bare-http1": "^4.1.6",
     "bare-https": "^2.1.3",
-    "bare-link": "^2.1.10",
+    "bare-link": "^3.2.1",
     "bare-net": "^2.2.0",
     "bare-os": "^3.6.2",
     "bare-path": "^3.0.0",
@@ -257,7 +256,7 @@
     "hyperswarm": "^4.12.1",
     "llm-splitter": "~0.2.0",
     "pear-pipe": "^1.0.6",
-    "react-native-bare-kit": "^0.11.5",
+    "react-native-bare-kit": "0.12.3",
     "tar-stream": "^3.1.8"
   },
   "peerDependenciesMeta": {
@@ -286,8 +285,5 @@
       "optional": true
     }
   },
-  "patchedDependencies": {},
-  "overrides": {
-    "@qvac/dl-hyperdrive": "^0.2.0"
-  }
+  "patchedDependencies": {}
 }

package/dist/examples/translation/translation-opus.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=translation-opus.d.ts.map

package/dist/examples/translation/translation-opus.js

@@ -1,33 +0,0 @@
-import { loadModel, translate, unloadModel, MARIAN_OPUS_EN_IT_Q4_0, } from "@qvac/sdk";
-try {
-    const modelId = await loadModel({
-        modelSrc: MARIAN_OPUS_EN_IT_Q4_0,
-        modelType: "nmt",
-        modelConfig: {
-            engine: "Opus",
-            from: "en",
-            to: "it",
-            temperature: 0.2,
-            norepeatngramsize: 3,
-            lengthpenalty: 1.2,
-        },
-        onProgress: (progress) => {
-            console.log(progress);
-        },
-    });
-    console.log(`✅ Model loaded: ${modelId}`);
-    const text = "Hello, how are you today?";
-    const result = translate({
-        modelId,
-        text,
-        modelType: "nmt",
-        stream: false,
-    });
-    const translatedText = await result.text;
-    console.log(`Translated text EN -> IT: ${text} -> "${translatedText}"`);
-    await unloadModel({ modelId });
-}
-catch (error) {
-    console.error("❌ Error:", error);
-    process.exit(1);
-}

package/dist/server/bare/utils/loader-adapter.d.ts

@@ -1,7 +0,0 @@
-import type FilesystemDL from "@qvac/dl-filesystem";
-/**
- * Adapts FilesystemDL to addon Loader interface by adding download stub.
- * download() is never called when using filesystem loader.
- */
-export declare function asLoader<T>(loader: FilesystemDL): T;
-//# sourceMappingURL=loader-adapter.d.ts.map