@qvac/sdk 0.9.2 → 0.10.1

package/dist/server/bare/registry/registry-client.js

@@ -1,35 +1,95 @@
 import { QVACRegistryClient } from "@qvac/registry-client";
-import { getCacheDir } from "../../utils/cache.js";
+import { getCacheDir } from "../../utils/cache/paths.js";
 import { registerSwarm, unregisterSwarm, registerCorestore, unregisterCorestore, } from "../runtime-lifecycle.js";
 import { getServerLogger } from "../../../logging/index.js";
 import { DEFAULT_REGISTRY_CORE_KEY } from "../../../constants/index.js";
 const logger = getServerLogger();
+// fd-lock retry budget for the registry corestore.
+//
+// We pass `corestoreOpts: { wait: false }` (tryLock semantics) and provide a
+// JS-bounded retry budget here instead of letting Hypercore's underlying
+// fd-lock issue a blocking flock(LOCK_EX) on a libuv worker thread. The
+// blocking variant cannot be cancelled from JS, so if another SDK process
+// holds the lock indefinitely it leaves a pending native handle that
+// prevents process.exit() from terminating the worker — see QVAC-18197.
+//
+// With tryLock + bounded retries we get the same "tolerate transient locks
+// during another SDK's startup/shutdown" property #1480 wanted, but every
+// retry step is a fresh non-blocking syscall that surfaces failure to JS,
+// so shutdown always remains cancellable.
+const MAX_RETRIES = 8;
+const BASE_DELAY_MS = 250;
+const MAX_TOTAL_WAIT_MS = 10_000;
 let registryClient = null;
+let inflightInit = null;
+function isFdLockError(error) {
+    if (error instanceof Error) {
+        return error.message.includes("File descriptor could not be locked");
+    }
+    return false;
+}
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function initRegistryClient() {
+    let lastError;
+    const deadline = Date.now() + MAX_TOTAL_WAIT_MS;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const client = new QVACRegistryClient({
+                registryCoreKey: DEFAULT_REGISTRY_CORE_KEY,
+                storage: getCacheDir(`registry-corestore/${DEFAULT_REGISTRY_CORE_KEY}`),
+                corestoreOpts: { wait: false },
+            });
+            await client.ready();
+            registryClient = client;
+            if (registryClient.corestore) {
+                registerCorestore(registryClient.corestore, {
+                    label: "registry-client",
+                    createdAt: Date.now(),
+                });
+            }
+            if (registryClient.hyperswarm) {
+                registerSwarm(registryClient.hyperswarm, {
+                    label: "registry-client",
+                    createdAt: Date.now(),
+                });
+            }
+            logger.info("✅ Registry client ready");
+            return client;
+        }
+        catch (error) {
+            lastError = error;
+            if (isFdLockError(error) && attempt < MAX_RETRIES) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0) {
+                    logger.warn(`Registry client fd-lock failed after ${MAX_TOTAL_WAIT_MS}ms wait budget exhausted (attempt ${attempt}/${MAX_RETRIES})`);
+                    throw error;
+                }
+                const backoff = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), remaining);
+                logger.warn(`Registry client fd-lock failed (attempt ${attempt}/${MAX_RETRIES}), retrying in ${backoff}ms...`);
+                await delay(backoff);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
 export async function getRegistryClient() {
     if (registryClient) {
         logger.debug("Registry client reused");
         return registryClient;
     }
+    if (inflightInit) {
+        logger.debug("Registry client init already in progress, waiting...");
+        return inflightInit;
+    }
     logger.info("🔗 Creating new registry client...");
-    registryClient = new QVACRegistryClient({
-        registryCoreKey: DEFAULT_REGISTRY_CORE_KEY,
-        storage: getCacheDir(`registry-corestore/${DEFAULT_REGISTRY_CORE_KEY}`),
+    inflightInit = initRegistryClient().finally(() => {
+        inflightInit = null;
     });
-    await registryClient.ready();
-    if (registryClient.corestore) {
-        registerCorestore(registryClient.corestore, {
-            label: "registry-client",
-            createdAt: Date.now(),
-        });
-    }
-    if (registryClient.hyperswarm) {
-        registerSwarm(registryClient.hyperswarm, {
-            label: "registry-client",
-            createdAt: Date.now(),
-        });
-    }
-    logger.info("✅ Registry client ready");
-    return registryClient;
+    return inflightInit;
 }
 export async function closeRegistryClient() {
     if (!registryClient)

package/dist/server/bare/runtime-lifecycle.d.ts

@@ -1,3 +1,4 @@
+import type { LifecycleState, Request } from "../../schemas/index";
 export interface SuspendableSwarm {
     readonly suspended: boolean;
     suspend(): Promise<void>;
@@ -7,7 +8,6 @@ export interface SuspendableStore {
     suspend(): Promise<void>;
     resume(): Promise<void>;
 }
-type LifecycleState = "active" | "suspending" | "suspended" | "resuming";
 interface ResourceMeta {
     label: string;
     createdAt: number;
@@ -17,6 +17,7 @@ export declare function unregisterSwarm(swarm: SuspendableSwarm): void;
 export declare function registerCorestore(store: SuspendableStore, meta: ResourceMeta): void;
 export declare function unregisterCorestore(store: SuspendableStore): void;
 export declare function getLifecycleState(): LifecycleState;
+export declare function assertLifecycleAllowed(request: Request): void;
 export declare function getRegisteredResourceCounts(): {
     swarms: number;
     stores: number;

package/dist/server/bare/runtime-lifecycle.js

@@ -1,5 +1,11 @@
 import { getServerLogger } from "../../logging/index.js";
+import { LifecycleOperationBlockedError } from "../../utils/errors-server.js";
 const logger = getServerLogger();
+const LIFECYCLE_ALLOWED_TYPES = new Set([
+    "suspend",
+    "resume",
+    "state",
+]);
 const swarms = new Map();
 const stores = new Map();
 let state = "active";
@@ -29,6 +35,11 @@ export function unregisterCorestore(store) {
 export function getLifecycleState() {
     return state;
 }
+export function assertLifecycleAllowed(request) {
+    if (state === "active" || LIFECYCLE_ALLOWED_TYPES.has(request.type))
+        return;
+    throw new LifecycleOperationBlockedError(request.type, state);
+}
 export function getRegisteredResourceCounts() {
     return { swarms: swarms.size, stores: stores.size };
 }
@@ -121,8 +132,8 @@ export async function resumeRuntime() {
         logger.info("▶️ Runtime resumed");
     })
         .catch((error) => {
-        state = "active";
-        logger.error("▶️ Runtime resume partially failed, state committed for recovery");
+        state = "suspended";
+        logger.error("▶️ Runtime resume partially failed, staying suspended for retry");
         throw error;
     })
         .finally(() => {

package/dist/server/bare/types/addon-responses.d.ts

@@ -53,10 +53,15 @@ export interface TranscribeStats {
     decoderMs?: number;
     melSpecMs?: number;
 }
+export interface TranscribeAddonSegment {
+    text: string;
+    start?: number;
+    end?: number;
+    toAppend?: boolean;
+    id?: number;
+}
 export interface TranscribeResponse {
     stats?: TranscribeStats;
-    iterate(): AsyncIterable<Array<{
-        text: string;
-    }>>;
+    iterate(): AsyncIterable<Array<TranscribeAddonSegment>>;
 }
 //# sourceMappingURL=addon-responses.d.ts.map

package/dist/server/bare/utils/transcribe-metadata.d.ts

@@ -0,0 +1,21 @@
+import { type TranscribeSegment } from "../../../schemas/index";
+export interface WhisperAddonSegment {
+    text: string;
+    start?: number;
+    end?: number;
+    toAppend?: boolean;
+    id?: number;
+}
+/**
+ * Normalize a native whisper-addon segment to the SDK-level `TranscribeSegment`
+ * shape exposed to callers: seconds → milliseconds, `toAppend` → `append`,
+ * and defaults for optional fields.
+ */
+export declare function toTranscribeSegment(chunk: WhisperAddonSegment): TranscribeSegment;
+/**
+ * Guard used by transcription ops when the caller opts into `metadata: true`.
+ * Only the whisper engine emits per-segment metadata; any other engine
+ * requesting metadata is rejected with `TranscriptionFailedError`.
+ */
+export declare function assertMetadataSupported(modelId: string, engineType: string, metadata: boolean | undefined): void;
+//# sourceMappingURL=transcribe-metadata.d.ts.map

package/dist/server/bare/utils/transcribe-metadata.js

@@ -0,0 +1,28 @@
+import { ModelType } from "../../../schemas/index.js";
+import { TranscriptionFailedError } from "../../../utils/errors-server.js";
+/**
+ * Normalize a native whisper-addon segment to the SDK-level `TranscribeSegment`
+ * shape exposed to callers: seconds → milliseconds, `toAppend` → `append`,
+ * and defaults for optional fields.
+ */
+export function toTranscribeSegment(chunk) {
+    return {
+        text: chunk.text,
+        startMs: (chunk.start ?? 0) * 1000,
+        endMs: (chunk.end ?? 0) * 1000,
+        append: chunk.toAppend ?? false,
+        id: chunk.id ?? 0,
+    };
+}
+/**
+ * Guard used by transcription ops when the caller opts into `metadata: true`.
+ * Only the whisper engine emits per-segment metadata; any other engine
+ * requesting metadata is rejected with `TranscriptionFailedError`.
+ */
+export function assertMetadataSupported(modelId, engineType, metadata) {
+    if (!metadata)
+        return;
+    if (engineType !== ModelType.whispercppTranscription) {
+        throw new TranscriptionFailedError(`metadata mode is not supported on model ${modelId} (engine: ${engineType || "unknown"}); only the whisper engine supports metadata`);
+    }
+}

package/dist/server/bare/utils/tts-stats.d.ts

@@ -0,0 +1,22 @@
+import type { TtsStats } from "../../../schemas/index";
+/**
+ * Shared types and utilities for TTS operations.
+ * Used by both text-to-speech.ts and text-to-speech-stream.ts.
+ */
+export type TtsStreamChunk = {
+    outputArray: ArrayLike<number>;
+    chunkIndex?: number;
+    sentenceChunk?: string;
+};
+export type TtsOpYield = {
+    buffer: number[];
+    chunkIndex?: number;
+    sentenceChunk?: string;
+};
+export declare function collectTtsStats(response: {
+    stats?: {
+        audioDurationMs?: number;
+        totalSamples?: number;
+    };
+}): TtsStats;
+//# sourceMappingURL=tts-stats.d.ts.map

package/dist/server/bare/utils/tts-stats.js

@@ -0,0 +1,10 @@
+export function collectTtsStats(response) {
+    return {
+        ...(response.stats?.audioDurationMs !== undefined && {
+            audioDuration: response.stats.audioDurationMs,
+        }),
+        ...(response.stats?.totalSamples !== undefined && {
+            totalSamples: response.stats.totalSamples,
+        }),
+    };
+}

package/dist/server/rpc/create-server.d.ts

@@ -1,4 +1,7 @@
 import RPC from "bare-rpc";
 export declare function createBareKitRPCServer(): RPC;
-export declare function createIPCClient(socketPath: string): RPC;
+export interface IPCClientOptions {
+    onDisconnect?: () => void;
+}
+export declare function createIPCClient(socketPath: string, options?: IPCClientOptions): RPC;
 //# sourceMappingURL=create-server.d.ts.map

package/dist/server/rpc/create-server.js

@@ -8,7 +8,7 @@ export function createBareKitRPCServer() {
         .BareKit;
     return new RPC(IPC, handleRequest);
 }
-export function createIPCClient(socketPath) {
+export function createIPCClient(socketPath, options) {
     logger.info(`Connecting to IPC socket at ${socketPath}`);
     const socket = connect(socketPath);
     socket.on("connect", () => {
@@ -17,5 +17,9 @@ export function createIPCClient(socketPath) {
     socket.on("error", (err) => {
         logger.error("IPC client connection error:", err);
     });
+    socket.on("close", () => {
+        logger.warn("IPC socket closed — parent process likely terminated");
+        options?.onDisconnect?.();
+    });
     return new RPC(socket, handleRequest);
 }

package/dist/server/rpc/delegate-transport.js

@@ -4,8 +4,8 @@
  * This module provides `send` and `stream` functions for server-side
  * delegation to remote peers (via HyperSwarm RPC).
  */
-import { requestSchema, responseSchema, PROFILING_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, } from "../../schemas/index.js";
-import { nowMs, extractProfilingMeta, recordFailure, generateId, } from "../../profiling/index.js";
+import { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, } from "../../schemas/index.js";
+import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId, } from "../../profiling/index.js";
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
 import { getServerLogger } from "../../logging/index.js";
 import { DelegateProviderError } from "../../utils/errors-server.js";
@@ -48,7 +48,8 @@ async function sendBase(request, rpc, options, profilingMeta) {
         const payload = JSON.stringify(finalRequest);
         req.send(payload, "utf-8");
         const response = await withTimeout(req.reply("utf-8"), options?.timeout);
-        const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
+        const rawPayload = JSON.parse(response?.toString() || "{}");
+        const resPayload = responseSchema.parse(stripProfilingMeta(rawPayload));
         logger.debug("[delegate-transport] Response:", { type: resPayload.type });
         checkAndThrowError(resPayload);
         return resPayload;
@@ -92,12 +93,13 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
         const parseStart = nowMs();
         const rawPayload = JSON.parse(response?.toString() || "{}");
         timings.responseJsonParseMs = nowMs() - parseStart;
-        const resPayload = responseSchema.parse(rawPayload);
+        const serverMeta = extractProfilingMeta(rawPayload);
+        const cleanPayload = stripProfilingMeta(rawPayload);
+        const resPayload = responseSchema.parse(cleanPayload);
         logger.debug("[delegate-transport] Response (profiled):", {
             type: resPayload.type,
         });
         checkAndThrowError(resPayload);
-        const serverMeta = extractProfilingMeta(rawPayload);
         const delegationBreakdown = recordDelegationEvents(timings, serverMeta, connectionMs);
         resPayload[DELEGATION_BREAKDOWN_KEY] = delegationBreakdown;
         if (serverMeta?.operation) {
@@ -150,11 +152,14 @@ async function* streamBase(request, rpc, options = {}, profilingMeta) {
             const lines = buffer.split("\n");
             buffer = lines.pop() || ""; // Keep incomplete line in buffer
             for (const line of lines) {
-                if (line.trim()) {
-                    const response = responseSchema.parse(JSON.parse(line));
-                    checkAndThrowError(response);
-                    yield response;
-                }
+                if (!line.trim())
+                    continue;
+                const rawPayload = JSON.parse(line);
+                if (rawPayload[PROFILING_TRAILER_KEY] === true)
+                    continue;
+                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
+                checkAndThrowError(response);
+                yield response;
             }
         }
     }
@@ -198,26 +203,28 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
             const lines = buffer.split("\n");
             buffer = lines.pop() || "";
             for (const line of lines) {
-                if (line.trim()) {
-                    const rawPayload = JSON.parse(line);
-                    const response = responseSchema.parse(rawPayload);
-                    checkAndThrowError(response);
-                    timings.chunkCount++;
-                    if (timings.firstChunkAt === undefined) {
-                        timings.firstChunkAt = nowMs();
-                    }
-                    timings.lastChunkAt = nowMs();
-                    const serverMeta = extractProfilingMeta(rawPayload);
-                    if (serverMeta?.operation) {
-                        response[OPERATION_EVENT_KEY] = serverMeta.operation;
-                    }
-                    if (serverMeta) {
-                        lastServerMeta = serverMeta;
-                    }
-                    response[DELEGATION_BREAKDOWN_KEY] =
-                        buildDelegationStreamBreakdown(timings);
-                    yield response;
+                if (!line.trim())
+                    continue;
+                const rawPayload = JSON.parse(line);
+                const serverMeta = extractProfilingMeta(rawPayload);
+                if (serverMeta) {
+                    lastServerMeta = serverMeta;
+                }
+                if (rawPayload[PROFILING_TRAILER_KEY] === true)
+                    continue;
+                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
+                checkAndThrowError(response);
+                timings.chunkCount++;
+                if (timings.firstChunkAt === undefined) {
+                    timings.firstChunkAt = nowMs();
+                }
+                timings.lastChunkAt = nowMs();
+                if (serverMeta?.operation) {
+                    response[OPERATION_EVENT_KEY] = serverMeta.operation;
                 }
+                response[DELEGATION_BREAKDOWN_KEY] =
+                    buildDelegationStreamBreakdown(timings);
+                yield response;
             }
         }
         recordDelegationStreamEvents(timings, lastServerMeta);

package/dist/server/rpc/handle-request.js

@@ -4,11 +4,15 @@ import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError, } from "../../utils/errors-server.js";
 import { registry } from "./handler-registry.js";
-import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
+import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage, } from "./handler-utils.js";
 import { createServerProfiler } from "./profiling/index.js";
+import { assertLifecycleAllowed } from "../bare/runtime-lifecycle.js";
+import { shouldUseStreamErrorTransport } from "./transport-selector.js";
 export async function handleRequest(req) {
     let profiler;
     let validationStart = 0;
+    let rawRequest;
+    let entry;
     try {
         const rawData = req.data?.toString();
         // Duplex stream request: metadata arrives as the first chunk on the
@@ -27,7 +31,21 @@ export async function handleRequest(req) {
             handleInitConfig(req, jsonData);
             return;
         }
+        // Handle internal pre-terminate cleanup signal (bypasses schema). Lets
+        // the client tear addons down while the JS env is still alive so static
+        // js_ref_t state doesn't survive into the next worklet's isolate.
+        if (isShutdownMessage(jsonData)) {
+            await handleShutdown(req);
+            return;
+        }
         const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
+        if (cleanData && typeof cleanData === "object") {
+            rawRequest = cleanData;
+            const rawType = rawRequest["type"];
+            if (typeof rawType === "string") {
+                entry = registry[rawType];
+            }
+        }
         profiler = createServerProfiler(profilingMeta);
         profiler.markRequestParsed(jsonParseMs);
         validationStart = nowMs();
@@ -36,7 +54,8 @@ export async function handleRequest(req) {
         attachProfilingMetaToRequest(request, profilingMeta);
         profiler.markRequestValidated(nowMs() - validationStart);
         validationStart = 0;
-        const entry = registry[request.type];
+        assertLifecycleAllowed(request);
+        entry = registry[request.type];
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);
         }
@@ -46,7 +65,12 @@ export async function handleRequest(req) {
         if (profiler && validationStart > 0) {
             profiler.markRequestValidated(nowMs() - validationStart);
         }
-        sendErrorResponse(req, error, profiler);
+        if (shouldUseStreamErrorTransport(entry, rawRequest)) {
+            sendStreamErrorResponse(req.createResponseStream(), error, profiler);
+        }
+        else {
+            sendErrorResponse(req, error, profiler);
+        }
     }
 }
 function attachProfilingMetaToRequest(request, profilingMeta) {
@@ -99,6 +123,7 @@ async function handleDuplexRequest(req) {
         const request = requestSchema.parse(processedData);
         attachProfilingMetaToRequest(request, profilingMeta);
         profiler.markRequestValidated(nowMs() - validationStart);
+        assertLifecycleAllowed(request);
         const entry = registry[request.type];
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);

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

@@ -18,7 +18,9 @@ import { stopProvideHandler } from "./handlers/stopProvideHandler.js";
 import { handleRag } from "./handlers/rag.js";
 import { handleDeleteCache } from "./handlers/delete-cache.js";
 import { handleTextToSpeech } from "./handlers/text-to-speech.js";
+import { handleTextToSpeechStream } from "./handlers/text-to-speech-stream.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
+import { handleGetLoadedModelInfo } from "./handlers/get-loaded-model-info.js";
 import { handleOCRStream } from "./handlers/ocr-stream.js";
 import { handleHeartbeat } from "./handlers/heartbeat.js";
 import { handleFinetune } from "./handlers/finetune.js";
@@ -29,6 +31,7 @@ import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
 import { handleSuspend } from "./handlers/suspend.js";
 import { handleResume } from "./handlers/resume.js";
+import { handleState } from "./handlers/state.js";
 function ragSupportsProgress(request) {
     if (request.type !== "rag")
         return false;
@@ -48,7 +51,7 @@ function isModelDelegated(request) {
 function isCancelDelegated(request) {
     if (request.type !== "cancel")
         return false;
-    if (request.operation === "inference") {
+    if (request.operation === "inference" || request.operation === "embeddings") {
         return isModelDelegated(request);
     }
     if (request.operation === "downloadAsset") {
@@ -81,6 +84,7 @@ export const registry = {
     stopProvide: { type: "reply", handler: stopProvideHandler },
     deleteCache: { type: "reply", handler: handleDeleteCache },
     getModelInfo: { type: "reply", handler: handleGetModelInfo },
+    getLoadedModelInfo: { type: "reply", handler: handleGetLoadedModelInfo },
     pluginInvoke: { type: "reply", handler: handlePluginInvoke },
     modelRegistryList: { type: "reply", handler: handleModelRegistryList },
     modelRegistrySearch: { type: "reply", handler: handleModelRegistrySearch },
@@ -90,12 +94,14 @@ export const registry = {
     },
     suspend: { type: "reply", handler: handleSuspend },
     resume: { type: "reply", handler: handleResume },
+    state: { type: "reply", handler: handleState },
     // Simple Stream handlers
     transcribe: { type: "stream", handler: handleTranscribe },
     transcribeStream: { type: "duplex", handler: handleTranscribeStream },
     loggingStream: { type: "stream", handler: handleLoggingStream },
     translate: { type: "stream", handler: handleTranslate },
     textToSpeech: { type: "stream", handler: handleTextToSpeech },
+    textToSpeechStream: { type: "duplex", handler: handleTextToSpeechStream },
     ocrStream: { type: "stream", handler: handleOCRStream },
     diffusionStream: { type: "stream", handler: handleDiffusionStream },
     pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },

package/dist/server/rpc/handler-utils.d.ts

@@ -21,5 +21,10 @@ type InitConfigMessage = {
 };
 export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
 export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
+type ShutdownMessage = {
+    type: "__shutdown__";
+};
+export declare function isShutdownMessage(data: unknown): data is ShutdownMessage;
+export declare function handleShutdown(req: RPC.IncomingRequest): Promise<void>;
 export {};
 //# sourceMappingURL=handler-utils.d.ts.map

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

@@ -170,3 +170,25 @@ export function handleInitConfig(req, data) {
         }), "utf-8");
     }
 }
+export function isShutdownMessage(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "type" in data &&
+        data.type === "__shutdown__");
+}
+export async function handleShutdown(req) {
+    try {
+        // Lazy import to avoid the import cycle:
+        //   handler-utils -> worker-core -> create-server -> handle-request
+        //   -> handler-utils. By the time this runs, all modules are loaded.
+        const { cleanupForTerminate } = await import("../worker-core.js");
+        await cleanupForTerminate();
+        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/cancel-delegated.js

@@ -4,13 +4,12 @@ import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { send } from "../delegate-transport.js";
 const logger = getServerLogger();
 function resolveDelegationTarget(request) {
-    if (request.operation === "inference") {
+    if (request.operation === "inference" || request.operation === "embeddings") {
         const entry = getModelEntry(request.modelId);
-        if (!entry?.isDelegated || !entry.delegated) {
+        if (!entry?.isDelegated) {
             return null;
         }
         const target = {
-            topic: entry.delegated.topic,
             providerPublicKey: entry.delegated.providerPublicKey,
         };
         if (entry.delegated.timeout !== undefined) {
@@ -20,7 +19,6 @@ function resolveDelegationTarget(request) {
     }
     if (request.operation === "downloadAsset" && request.delegate) {
         const target = {
-            topic: request.delegate.topic,
             providerPublicKey: request.delegate.providerPublicKey,
         };
         if (request.delegate.timeout !== undefined) {
@@ -45,7 +43,7 @@ export async function handleCancelDelegated(request, options) {
         return { type: "cancel", success: true };
     }
     try {
-        const rpc = await getRPC(target.topic, target.providerPublicKey, {
+        const rpc = await getRPC(target.providerPublicKey, {
             timeout: target.timeout,
         });
         const delegateOpts = {

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

@@ -1,5 +1,5 @@
 import { cancel } from "../../bare/ops/cancel.js";
-import { createCancelFunction } from "./load-model/download-manager.js";
+import { cancelTransfer } from "./load-model/download-manager.js";
 import { cancelRagOperation, DEFAULT_WORKSPACE, } from "../../bare/rag-hyperdb/index.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -7,13 +7,12 @@ export async function cancelHandler(request) {
     try {
         switch (request.operation) {
             case "inference":
+            case "embeddings":
                 await cancel({ modelId: request.modelId });
                 break;
-            case "downloadAsset": {
-                const cancelDownload = createCancelFunction(request.downloadKey, request.clearCache);
-                cancelDownload();
+            case "downloadAsset":
+                cancelTransfer(request.downloadKey, request.clearCache);
                 break;
-            }
             case "rag": {
                 const cancelled = cancelRagOperation(request.workspace);
                 if (!cancelled) {