@qvac/sdk 0.9.1 → 0.10.0

package/dist/server/bare/plugins/sdcpp-generation/plugin.d.ts

@@ -62,6 +62,7 @@ export declare const diffusionPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -72,7 +73,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -92,6 +92,7 @@ export declare const diffusionPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -102,7 +103,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -122,6 +122,7 @@ export declare const diffusionPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -132,7 +133,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -152,6 +152,7 @@ export declare const diffusionPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -162,7 +163,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -182,6 +182,7 @@ export declare const diffusionPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -192,7 +193,6 @@ export declare const diffusionPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -212,6 +212,7 @@ export declare const diffusionPlugin: {
             height: import("zod").ZodOptional<import("zod").ZodNumber>;
             steps: import("zod").ZodOptional<import("zod").ZodNumber>;
             cfg_scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            img_cfg_scale: import("zod").ZodDefault<import("zod").ZodNumber>;
             guidance: import("zod").ZodOptional<import("zod").ZodNumber>;
             sampling_method: import("zod").ZodOptional<import("zod").ZodEnum<{
                 euler: "euler";
@@ -246,6 +247,8 @@ export declare const diffusionPlugin: {
             batch_count: import("zod").ZodOptional<import("zod").ZodNumber>;
             vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cache_preset: import("zod").ZodOptional<import("zod").ZodString>;
+            init_image: import("zod").ZodOptional<import("zod").ZodString>;
+            strength: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"diffusionStream">;
             step: import("zod").ZodOptional<import("zod").ZodNumber>;

package/dist/server/bare/plugins/sdcpp-generation/plugin.js

@@ -2,7 +2,6 @@ import ImgStableDiffusion, {} from "@qvac/diffusion-cpp";
 import addonLogging from "@qvac/diffusion-cpp/addonLogging.js";
 import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
 import { diffusion } from "./ops/diffusion.js";
 export const diffusionPlugin = definePlugin({
     modelType: ModelType.sdcppGeneration,
@@ -38,22 +37,23 @@ export const diffusionPlugin = definePlugin({
     createModel(params) {
         const { modelId, modelPath, modelConfig, artifacts } = params;
         const config = (modelConfig ?? {});
-        const { dirPath, basePath } = parseModelPath(modelPath);
         const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
         registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
-        const addonArgs = {
-            diskPath: dirPath,
-            modelName: basePath,
+        const files = {
+            model: modelPath,
+            ...(artifacts?.["clipLModelPath"] && { clipL: artifacts["clipLModelPath"] }),
+            ...(artifacts?.["clipGModelPath"] && { clipG: artifacts["clipGModelPath"] }),
+            ...(artifacts?.["t5XxlModelPath"] && { t5Xxl: artifacts["t5XxlModelPath"] }),
+            ...(artifacts?.["llmModelPath"] && { llm: artifacts["llmModelPath"] }),
+            ...(artifacts?.["vaeModelPath"] && { vae: artifacts["vaeModelPath"] }),
+        };
+        const model = new ImgStableDiffusion({
+            files,
+            config: config,
             logger,
             opts: { stats: true },
-            ...(artifacts?.["clipLModelPath"] && { clipLModel: artifacts["clipLModelPath"] }),
-            ...(artifacts?.["clipGModelPath"] && { clipGModel: artifacts["clipGModelPath"] }),
-            ...(artifacts?.["t5XxlModelPath"] && { t5XxlModel: artifacts["t5XxlModelPath"] }),
-            ...(artifacts?.["llmModelPath"] && { llmModel: artifacts["llmModelPath"] }),
-            ...(artifacts?.["vaeModelPath"] && { vaeModel: artifacts["vaeModelPath"] }),
-        };
-        const model = new ImgStableDiffusion(addonArgs, config);
-        return { model, loader: undefined };
+        });
+        return { model };
     },
     handlers: {
         diffusionStream: defineHandler({

package/dist/server/bare/plugins/whispercpp-transcription/plugin.d.ts

@@ -75,6 +75,7 @@ export declare const whisperPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -85,7 +86,6 @@ export declare const whisperPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -216,6 +216,7 @@ export declare const whisperPlugin: {
         transcribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             audioChunk: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"base64">;
                 value: import("zod").ZodString;
@@ -240,11 +241,19 @@ export declare const whisperPlugin: {
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
         transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
@@ -262,6 +271,13 @@ export declare const whisperPlugin: {
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"transcribeStream">;
         }, import("zod/v4/core").$strip>>;
     };

package/dist/server/bare/plugins/whispercpp-transcription/plugin.js

@@ -24,7 +24,7 @@ function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
         ...(miscConfig && { miscConfig }),
     };
     const model = new TranscriptionWhispercpp(args, config);
-    return { model, loader: null };
+    return { model };
 }
 export const whisperPlugin = definePlugin({
     modelType: ModelType.whispercppTranscription,
@@ -44,8 +44,8 @@ export const whisperPlugin = definePlugin({
     },
     createModel(params) {
         const whisperConfig = (params.modelConfig ?? {});
-        const { model, loader } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
-        return { model, loader };
+        const { model } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
+        return { model };
     },
     handlers: {
         transcribe: defineHandler({
@@ -53,18 +53,31 @@ export const whisperPlugin = definePlugin({
             responseSchema: transcribeResponseSchema,
             streaming: true,
             handler: async function* (request) {
-                const stream = transcribe({
-                    modelId: request.modelId,
-                    audioChunk: request.audioChunk,
-                    prompt: request.prompt,
-                });
+                const metadata = request.metadata === true;
+                const stream = metadata
+                    ? transcribe({
+                        modelId: request.modelId,
+                        audioChunk: request.audioChunk,
+                        prompt: request.prompt,
+                        metadata: true,
+                    })
+                    : transcribe({
+                        modelId: request.modelId,
+                        audioChunk: request.audioChunk,
+                        prompt: request.prompt,
+                    });
                 try {
                     let result = await stream.next();
                     while (!result.done) {
-                        yield {
-                            type: "transcribe",
-                            text: result.value,
-                        };
+                        yield metadata
+                            ? {
+                                type: "transcribe",
+                                segment: result.value,
+                            }
+                            : {
+                                type: "transcribe",
+                                text: result.value,
+                            };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
@@ -86,11 +99,21 @@ export const whisperPlugin = definePlugin({
             streaming: true,
             duplex: true,
             handler: async function* (request, inputStream) {
-                for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
-                    yield {
-                        type: "transcribeStream",
-                        text,
-                    };
+                if (request.metadata === true) {
+                    for await (const segment of transcribeStream(request.modelId, inputStream, request.prompt, true)) {
+                        yield {
+                            type: "transcribeStream",
+                            segment,
+                        };
+                    }
+                }
+                else {
+                    for await (const text of transcribeStream(request.modelId, inputStream, request.prompt)) {
+                        yield {
+                            type: "transcribeStream",
+                            text,
+                        };
+                    }
                 }
                 yield {
                     type: "transcribeStream",

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

@@ -1,6 +1,6 @@
 import fs from "bare-fs";
 import path from "bare-path";
-import { getEnv } from "../../env.js";
+import { getQvacPath } from "../../utils/qvac-paths.js";
 import { CacheDirNotAbsoluteError, CacheDirNotWritableError, ConfigAlreadySetError, } from "../../../utils/errors-server.js";
 import { getServerLogger, setGlobalConsoleOutput, setGlobalLogLevel, } from "../../../logging/index.js";
 const logger = getServerLogger();
@@ -10,6 +10,8 @@ const configRegistry = {
     loggerLevel: undefined,
     loggerConsoleOutput: undefined,
     httpDownloadConcurrency: undefined,
+    registryDownloadMaxRetries: undefined,
+    registryStreamTimeoutMs: undefined,
     deviceDefaults: undefined,
 };
 let configIsSet = false;
@@ -63,6 +65,16 @@ export function setSDKConfig(config) {
         configRegistry.httpDownloadConcurrency = config.httpDownloadConcurrency;
         logger.info(`HTTP download concurrency set to: ${config.httpDownloadConcurrency}`);
     }
+    if (config.registryDownloadMaxRetries !== undefined &&
+        config.registryDownloadMaxRetries !== null) {
+        configRegistry.registryDownloadMaxRetries = config.registryDownloadMaxRetries;
+        logger.info(`✅ Registry download max retries set to: ${config.registryDownloadMaxRetries}`);
+    }
+    if (config.registryStreamTimeoutMs !== undefined &&
+        config.registryStreamTimeoutMs !== null) {
+        configRegistry.registryStreamTimeoutMs = config.registryStreamTimeoutMs;
+        logger.info(`✅ Registry stream timeout set to: ${config.registryStreamTimeoutMs}ms`);
+    }
     if (config.deviceDefaults !== undefined && config.deviceDefaults !== null) {
         configRegistry.deviceDefaults = config.deviceDefaults;
         logger.info(`✅ Device defaults configured: ${config.deviceDefaults.length} pattern(s)`);
@@ -74,8 +86,7 @@ export function getSDKConfig() {
     return { ...configRegistry };
 }
 function getDefaultCacheDir() {
-    const homeDir = getEnv().HOME_DIR;
-    return path.join(homeDir, ".qvac", "models");
+    return getQvacPath("models");
 }
 export function getConfiguredCacheDir() {
     return configRegistry.cacheDirectory || getDefaultCacheDir();

package/dist/server/bare/registry/model-registry.d.ts

@@ -1,4 +1,3 @@
-import type FilesystemDL from "@qvac/dl-filesystem";
 import type { CanonicalModelType } from "../../../schemas/index";
 import type BaseInference from "@qvac/infer-base";
 interface AddonInterface {
@@ -9,7 +8,6 @@ export type AnyModel = Omit<BaseInference, "addon"> & {
     addon?: AddonInterface;
 };
 interface DelegateOptions {
-    topic: string;
     providerPublicKey: string;
     timeout?: number | undefined;
     healthCheckTimeout?: number | undefined;
@@ -21,23 +19,23 @@ interface LocalOptions {
     config: unknown;
     modelType: CanonicalModelType;
     name?: string | undefined;
-    loader?: FilesystemDL;
 }
-export interface ModelEntry {
+export type ModelEntry = {
     id: string;
-    isDelegated: boolean;
-    local?: LocalOptions;
-    delegated?: DelegateOptions;
-}
+    isDelegated: true;
+    delegated: DelegateOptions;
+} | {
+    id: string;
+    isDelegated: false;
+    local: LocalOptions;
+};
 export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
     modelType: CanonicalModelType;
-    loader?: FilesystemDL;
     name?: string | undefined;
 } | {
-    topic: string;
     providerPublicKey: string;
     timeout?: number;
     healthCheckTimeout?: number;

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

@@ -7,20 +7,19 @@ export function registerModel(id, options) {
     if (modelRegistry.has(id)) {
         throw new ModelAlreadyRegisteredError(id);
     }
-    const isDelegated = "topic" in options && "providerPublicKey" in options;
+    const isDelegated = "providerPublicKey" in options;
     if (isDelegated) {
-        const { topic, providerPublicKey, timeout, healthCheckTimeout } = options;
+        const { providerPublicKey, timeout, healthCheckTimeout } = options;
         modelRegistry.set(id, {
             id,
             isDelegated: true,
             delegated: {
-                topic,
                 providerPublicKey,
                 timeout,
                 healthCheckTimeout,
             },
         });
-        logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+        logger.info(`Delegated model registered: ${id} -> provider: ${providerPublicKey}, timeout: ${timeout}ms`);
     }
     else {
         modelRegistry.set(id, {
@@ -32,7 +31,6 @@ export function registerModel(id, options) {
                 loadedAt: new Date(),
                 config: options.config,
                 modelType: options.modelType,
-                ...(options.loader && { loader: options.loader }),
                 name: options.name,
             },
         });
@@ -48,7 +46,7 @@ export function getModel(id) {
     if (!entry) {
         throw new ModelNotFoundError(id);
     }
-    if (!entry.local) {
+    if (entry.isDelegated) {
         throw new ModelIsDelegatedError(id);
     }
     return entry.local.model;
@@ -70,7 +68,7 @@ export function getAllModelIds() {
 }
 export function getModelInfo(id) {
     const entry = modelRegistry.get(id);
-    if (!entry || !entry.local) {
+    if (!entry || entry.isDelegated) {
         return null;
     }
     const result = {
@@ -86,7 +84,7 @@ export function getModelInfo(id) {
 }
 export function getModelConfig(id) {
     const entry = modelRegistry.get(id);
-    if (!entry || !entry.local) {
+    if (!entry || entry.isDelegated) {
         throw new ModelNotFoundError(id);
     }
     return entry.local.config;
@@ -96,7 +94,7 @@ export function updateModelConfig(id, config) {
     if (!entry) {
         throw new ModelNotFoundError(id);
     }
-    if (!entry.local) {
+    if (entry.isDelegated) {
         throw new ModelIsDelegatedError(id);
     }
     entry.local.config = config;
@@ -115,9 +113,16 @@ export async function unloadAllModels() {
     const modelIds = getAllModelIds();
     for (const modelId of modelIds) {
         const entry = modelRegistry.get(modelId);
-        if (entry?.local?.model && entry.local.model.unload) {
-            await entry.local.model.unload();
-            logger.debug(`Model unloaded: ${modelId}`);
+        try {
+            if (entry && !entry.isDelegated) {
+                if (entry.local.model.unload) {
+                    await entry.local.model.unload();
+                }
+                logger.debug(`Model unloaded: ${modelId}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Error unloading model ${modelId}:`, error instanceof Error ? error.message : String(error));
         }
         modelRegistry.delete(modelId);
     }

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