@qvac/sdk 0.6.0 → 0.7.0

package/dist/server/bare/plugins/onnx-tts/plugin.d.ts

@@ -0,0 +1,26 @@
+import { type CreateModelParams, type PluginModelResult, type ResolveModelPath } from "../../../../schemas/index";
+export declare const ttsPlugin: {
+    modelType: "onnx-tts";
+    displayName: string;
+    addonPackage: string;
+    resolveConfig(modelConfig: Record<string, unknown>, resolve: ResolveModelPath): Promise<Record<string, unknown>>;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        textToSpeech: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            inputType: import("zod").ZodDefault<import("zod").ZodString>;
+            text: import("zod").ZodString;
+            stream: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            type: import("zod").ZodLiteral<"textToSpeech">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"textToSpeech">;
+            buffer: import("zod").ZodArray<import("zod").ZodNumber>;
+            done: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/tts-onnx/addonLogging").AddonLogging;
+        namespace: "tts";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/onnx-tts/plugin.js

@@ -0,0 +1,162 @@
+import path from "bare-path";
+import ttsAddonLogging from "@qvac/tts-onnx/addonLogging.js";
+import ONNXTTS from "@qvac/tts-onnx";
+import { definePlugin, defineHandler, ttsRequestSchema, ttsResponseSchema, ModelType, } from "../../../../schemas/index.js";
+import { ADDON_NAMESPACES, createStreamLogger } from "../../../../logging/index.js";
+import { TtsArtifactsRequiredError, TtsReferenceAudioRequiredError, } from "../../../../utils/errors-server.js";
+import { textToSpeech } from "./ops/text-to-speech.js";
+import { loadReferenceAudioAt24k } from "./wav-helper.js";
+async function resolveChatterboxConfig(config, resolve) {
+    const { ttsTokenizerSrc, ttsSpeechEncoderSrc, ttsEmbedTokensSrc, ttsConditionalDecoderSrc, ttsLanguageModelSrc, referenceAudioSrc, language, } = config;
+    if (!ttsTokenizerSrc ||
+        !ttsSpeechEncoderSrc ||
+        !ttsEmbedTokensSrc ||
+        !ttsConditionalDecoderSrc ||
+        !ttsLanguageModelSrc) {
+        throw new TtsArtifactsRequiredError();
+    }
+    if (!referenceAudioSrc) {
+        throw new TtsReferenceAudioRequiredError();
+    }
+    // Download sequentially to avoid race conditions with registry client
+    const resolvedTokenizer = await resolve(ttsTokenizerSrc);
+    const resolvedSpeechEncoder = await resolve(ttsSpeechEncoderSrc);
+    const resolvedEmbedTokens = await resolve(ttsEmbedTokensSrc);
+    const resolvedConditionalDecoder = await resolve(ttsConditionalDecoderSrc);
+    const resolvedLanguageModel = await resolve(ttsLanguageModelSrc);
+    const resolvedReferenceAudio = await resolve(referenceAudioSrc);
+    const result = {
+        ttsEngine: "chatterbox",
+        ttsTokenizerSrc: resolvedTokenizer,
+        ttsSpeechEncoderSrc: resolvedSpeechEncoder,
+        ttsEmbedTokensSrc: resolvedEmbedTokens,
+        ttsConditionalDecoderSrc: resolvedConditionalDecoder,
+        ttsLanguageModelSrc: resolvedLanguageModel,
+        referenceAudioSrc: resolvedReferenceAudio,
+    };
+    if (language)
+        result.language = language;
+    return result;
+}
+async function resolveSupertonicConfig(config, resolve) {
+    const { ttsTokenizerSrc, ttsTextEncoderSrc, ttsLatentDenoiserSrc, ttsVoiceDecoderSrc, ttsVoiceSrc, ttsSpeed, ttsNumInferenceSteps, language, } = config;
+    if (!ttsTokenizerSrc ||
+        !ttsTextEncoderSrc ||
+        !ttsLatentDenoiserSrc ||
+        !ttsVoiceDecoderSrc ||
+        !ttsVoiceSrc) {
+        throw new TtsArtifactsRequiredError();
+    }
+    // Download sequentially to avoid race conditions with registry client
+    const resolvedTokenizer = await resolve(ttsTokenizerSrc);
+    const resolvedTextEncoder = await resolve(ttsTextEncoderSrc);
+    const resolvedLatentDenoiser = await resolve(ttsLatentDenoiserSrc);
+    const resolvedVoiceDecoder = await resolve(ttsVoiceDecoderSrc);
+    const resolvedVoice = await resolve(ttsVoiceSrc);
+    const result = {
+        ttsEngine: "supertonic",
+        ttsTokenizerSrc: resolvedTokenizer,
+        ttsTextEncoderSrc: resolvedTextEncoder,
+        ttsLatentDenoiserSrc: resolvedLatentDenoiser,
+        ttsVoiceDecoderSrc: resolvedVoiceDecoder,
+        ttsVoiceSrc: resolvedVoice,
+    };
+    if (language)
+        result.language = language;
+    if (ttsSpeed !== undefined)
+        result.ttsSpeed = ttsSpeed;
+    if (ttsNumInferenceSteps !== undefined)
+        result.ttsNumInferenceSteps = ttsNumInferenceSteps;
+    return result;
+}
+function createChatterboxModel(modelId, config) {
+    const { ttsTokenizerSrc: tokenizerPath, ttsSpeechEncoderSrc: speechEncoderPath, ttsEmbedTokensSrc: embedTokensPath, ttsConditionalDecoderSrc: conditionalDecoderPath, ttsLanguageModelSrc: languageModelPath, referenceAudioSrc: referenceAudioPath, language, } = config;
+    if (!tokenizerPath ||
+        !speechEncoderPath ||
+        !embedTokensPath ||
+        !conditionalDecoderPath ||
+        !languageModelPath) {
+        throw new TtsArtifactsRequiredError();
+    }
+    if (!referenceAudioPath) {
+        throw new TtsReferenceAudioRequiredError();
+    }
+    const logger = createStreamLogger(modelId, "tts");
+    const referenceAudio = loadReferenceAudioAt24k(referenceAudioPath);
+    const args = {
+        tokenizerPath,
+        speechEncoderPath,
+        embedTokensPath,
+        conditionalDecoderPath,
+        languageModelPath,
+        referenceAudio,
+        logger,
+        opts: { stats: true },
+    };
+    const modelConfig = { language: language ?? "en", useGPU: false };
+    const model = new ONNXTTS(args, modelConfig);
+    return { model, loader: undefined };
+}
+function createSupertonicModel(modelId, config) {
+    const { ttsTokenizerSrc: tokenizerPath, ttsTextEncoderSrc: textEncoderPath, ttsLatentDenoiserSrc: latentDenoiserPath, ttsVoiceDecoderSrc: voiceDecoderPath, ttsVoiceSrc: voicePath, ttsSpeed: speed, ttsNumInferenceSteps: numInferenceSteps, language, } = config;
+    if (!tokenizerPath ||
+        !textEncoderPath ||
+        !latentDenoiserPath ||
+        !voiceDecoderPath ||
+        !voicePath) {
+        throw new TtsArtifactsRequiredError();
+    }
+    const logger = createStreamLogger(modelId, "tts");
+    const voicesDir = path.dirname(voicePath);
+    const voiceName = path.basename(voicePath).replace(/\.bin$/i, "") || "voice";
+    const args = {
+        tokenizerPath,
+        textEncoderPath,
+        latentDenoiserPath,
+        voiceDecoderPath,
+        voicesDir,
+        voiceName,
+        speed: speed ?? 1,
+        numInferenceSteps: numInferenceSteps ?? 5,
+        logger,
+        opts: { stats: true },
+    };
+    const modelConfig = { language: language ?? "en" };
+    const model = new ONNXTTS(args, modelConfig);
+    return { model, loader: undefined };
+}
+export const ttsPlugin = definePlugin({
+    modelType: ModelType.onnxTts,
+    displayName: "TTS (ONNX)",
+    addonPackage: "@qvac/tts-onnx",
+    async resolveConfig(modelConfig, resolve) {
+        const config = modelConfig;
+        if (config.ttsEngine === "supertonic") {
+            return resolveSupertonicConfig(config, resolve);
+        }
+        return resolveChatterboxConfig(config, resolve);
+    },
+    createModel(params) {
+        const config = (params.modelConfig ?? {});
+        if (config.ttsEngine === "supertonic") {
+            return createSupertonicModel(params.modelId, config);
+        }
+        return createChatterboxModel(params.modelId, config);
+    },
+    handlers: {
+        textToSpeech: defineHandler({
+            requestSchema: ttsRequestSchema,
+            responseSchema: ttsResponseSchema,
+            streaming: true,
+            handler: async function* (request) {
+                for await (const response of textToSpeech(request)) {
+                    yield response;
+                }
+            },
+        }),
+    },
+    logging: {
+        module: ttsAddonLogging,
+        namespace: ADDON_NAMESPACES.TTS,
+    },
+});

package/dist/server/bare/plugins/onnx-tts/wav-helper.d.ts

@@ -0,0 +1,14 @@
+export type ReadWavResult = {
+    samples: Float32Array;
+    sampleRate: number;
+};
+/**
+ * Read a WAV file and return Float32Array of mono samples in [-1, 1].
+ * Supports 16-bit PCM and 32-bit float; stereo is converted to mono (left channel).
+ */
+export declare function readWavAsFloat32(wavPath: string): ReadWavResult;
+/**
+ * Load reference audio from a WAV path and return Float32Array at 24kHz for Chatterbox.
+ */
+export declare function loadReferenceAudioAt24k(wavPath: string): Float32Array;
+//# sourceMappingURL=wav-helper.d.ts.map

package/dist/server/bare/plugins/onnx-tts/wav-helper.js

@@ -0,0 +1,107 @@
+import fs from "bare-fs";
+const CHATTERBOX_SAMPLE_RATE = 24000;
+/**
+ * Read a WAV file and return Float32Array of mono samples in [-1, 1].
+ * Supports 16-bit PCM and 32-bit float; stereo is converted to mono (left channel).
+ */
+export function readWavAsFloat32(wavPath) {
+    const buf = fs.readFileSync(wavPath);
+    if (buf.length < 44)
+        throw new Error("WAV file too small");
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const riff = String.fromCharCode(buf[0], buf[1], buf[2], buf[3]);
+    const wave = String.fromCharCode(buf[8], buf[9], buf[10], buf[11]);
+    if (riff !== "RIFF")
+        throw new Error("Not a RIFF file");
+    if (wave !== "WAVE")
+        throw new Error("Not WAVE format");
+    let fmtChunk = null;
+    let dataChunk = null;
+    let offset = 12;
+    while (offset + 8 <= buf.length) {
+        const chunkId = String.fromCharCode(buf[offset], buf[offset + 1], buf[offset + 2], buf[offset + 3]);
+        const chunkSize = view.getUint32(offset + 4, true);
+        if (chunkId === "fmt ")
+            fmtChunk = { offset: offset + 8, size: chunkSize };
+        else if (chunkId === "data")
+            dataChunk = { offset: offset + 8, size: chunkSize };
+        offset += 8 + chunkSize;
+        if (chunkSize % 2 === 1 && offset < buf.length)
+            offset += 1;
+    }
+    if (!fmtChunk)
+        throw new Error("WAV missing fmt chunk");
+    if (!dataChunk)
+        throw new Error("WAV missing data chunk");
+    const fmtOff = fmtChunk.offset;
+    if (fmtOff + 16 > buf.length)
+        throw new Error("fmt chunk truncated");
+    const audioFormat = view.getUint16(fmtOff, true);
+    const numChannels = view.getUint16(fmtOff + 2, true);
+    const sampleRate = view.getUint32(fmtOff + 4, true);
+    const bitsPerSample = view.getUint16(fmtOff + 14, true);
+    if (audioFormat !== 1 && audioFormat !== 3) {
+        throw new Error("Unsupported WAV audio format: " +
+            audioFormat +
+            " (only PCM=1 and IEEE_FLOAT=3 supported)");
+    }
+    const dataOff = dataChunk.offset;
+    const dataLen = Math.min(dataChunk.size, buf.length - dataOff);
+    let samples;
+    if (audioFormat === 1 && bitsPerSample === 16) {
+        const bytesPerSample = 2;
+        const numSamples = Math.floor(dataLen / bytesPerSample);
+        const numFrames = numChannels === 1 ? numSamples : Math.floor(numSamples / numChannels);
+        samples = new Float32Array(numFrames);
+        for (let i = 0; i < numFrames; i++) {
+            const idx = dataOff + (numChannels === 1 ? i * 2 : i * numChannels * 2);
+            if (idx + 2 > buf.length)
+                break;
+            const s = view.getInt16(idx, true);
+            samples[i] = s / 32768;
+        }
+    }
+    else if (audioFormat === 3 && bitsPerSample === 32) {
+        const bytesPerSample = 4;
+        const numSamples = Math.floor(dataLen / bytesPerSample);
+        const numFrames = numChannels === 1 ? numSamples : Math.floor(numSamples / numChannels);
+        samples = new Float32Array(numFrames);
+        for (let i = 0; i < numFrames; i++) {
+            const idx = dataOff + (numChannels === 1 ? i * 4 : i * numChannels * 4);
+            if (idx + 4 > buf.length)
+                break;
+            samples[i] = view.getFloat32(idx, true);
+        }
+    }
+    else {
+        throw new Error("Unsupported WAV format: audioFormat=" +
+            audioFormat +
+            ", bitsPerSample=" +
+            bitsPerSample);
+    }
+    return { samples, sampleRate };
+}
+function resampleLinear(samples, fromRate, toRate) {
+    if (fromRate === toRate)
+        return samples;
+    const ratio = fromRate / toRate;
+    const outputLen = Math.round(samples.length / ratio);
+    const output = new Float32Array(outputLen);
+    for (let i = 0; i < outputLen; i++) {
+        const srcIdx = i * ratio;
+        const lo = Math.floor(srcIdx);
+        const hi = Math.min(lo + 1, samples.length - 1);
+        const frac = srcIdx - lo;
+        output[i] = samples[lo] * (1 - frac) + samples[hi] * frac;
+    }
+    return output;
+}
+/**
+ * Load reference audio from a WAV path and return Float32Array at 24kHz for Chatterbox.
+ */
+export function loadReferenceAudioAt24k(wavPath) {
+    const { samples, sampleRate } = readWavAsFloat32(wavPath);
+    if (sampleRate === CHATTERBOX_SAMPLE_RATE)
+        return samples;
+    return resampleLinear(samples, sampleRate, CHATTERBOX_SAMPLE_RATE);
+}

package/dist/server/bare/plugins/whispercpp-transcription/ops/transcribe-stream.d.ts

@@ -0,0 +1,3 @@
+import type { TranscribeParams } from "../../../../../schemas/index";
+export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, void, void>;
+//# sourceMappingURL=transcribe-stream.d.ts.map

package/dist/server/bare/{addons/whispercpp-transcription/handlers → plugins/whispercpp-transcription/ops}/transcribe-stream.js

@@ -1,8 +1,7 @@
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
 import { Readable } from "bare-stream";
 import fs from "bare-fs";
-import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
-import {} from "../../../../../schemas/index.js";
+import { needsDecoding, decodeAudioToStream, } from "../../../../utils/audio/decoder.js";
 import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../../../utils/errors-server.js";
 import { getServerLogger } from "../../../../../logging/index.js";
 const logger = getServerLogger();

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

@@ -0,0 +1,31 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const whisperPlugin: {
+    modelType: "whispercpp-transcription";
+    displayName: string;
+    addonPackage: string;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        transcribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            audioChunk: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"base64">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"filePath">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "type">;
+            prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            type: import("zod").ZodLiteral<"transcribeStream">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"transcribeStream">;
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/transcription-whispercpp/addonLogging").AddonLogging;
+        namespace: "whispercpp";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1,74 @@
+import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
+import TranscriptionWhispercpp, {} from "@qvac/transcription-whispercpp";
+import { definePlugin, defineHandler, transcribeStreamRequestSchema, transcribeStreamResponseSchema, ModelType, } from "../../../../schemas/index.js";
+import { ADDON_NAMESPACES, createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+import { transcribe } from "./ops/transcribe-stream.js";
+function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    let vadModelName = "";
+    const effectiveVadPath = vadModelPath || whisperConfig.vad_model_path;
+    if (effectiveVadPath) {
+        const vadParsed = parseModelPath(effectiveVadPath);
+        vadModelName = vadParsed.basePath;
+    }
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, "whispercpp");
+    const args = {
+        loader,
+        logger,
+        modelName: basePath,
+        diskPath: dirPath,
+        vadModelName,
+        opts: {
+            stats: false,
+        },
+    };
+    const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
+    const config = {
+        whisperConfig: whisperParams,
+        ...(contextParams && { contextParams }),
+        ...(miscConfig && { miscConfig }),
+    };
+    const model = new TranscriptionWhispercpp(args, config);
+    return { model, loader };
+}
+export const whisperPlugin = definePlugin({
+    modelType: ModelType.whispercppTranscription,
+    displayName: "Whisper (whisper.cpp)",
+    addonPackage: "@qvac/transcription-whispercpp",
+    createModel(params) {
+        const whisperConfig = (params.modelConfig ?? {});
+        const { model, loader } = createWhisperModel(params.modelId, params.modelPath, whisperConfig, params.artifacts?.["vadModelPath"]);
+        return { model, loader };
+    },
+    handlers: {
+        transcribeStream: defineHandler({
+            requestSchema: transcribeStreamRequestSchema,
+            responseSchema: transcribeStreamResponseSchema,
+            streaming: true,
+            handler: async function* (request) {
+                for await (const text of transcribe({
+                    modelId: request.modelId,
+                    audioChunk: request.audioChunk,
+                    prompt: request.prompt,
+                })) {
+                    yield {
+                        type: "transcribeStream",
+                        text,
+                    };
+                }
+                yield {
+                    type: "transcribeStream",
+                    text: "",
+                    done: true,
+                };
+            },
+        }),
+    },
+    logging: {
+        module: whisperAddonLogging,
+        namespace: ADDON_NAMESPACES.WHISPERCPP,
+    },
+});

package/dist/server/bare/rag-hyperdb/handlers/ingest.js

@@ -1,5 +1,5 @@
 import { getRagInstance } from "../rag-workspace-manager.js";
-import { embed } from "../../addons/llamacpp-embedding/index.js";
+import { embed } from "../../ops/embed.js";
 import { ragIngestParamsSchema } from "../../../../schemas/index.js";
 export async function ingest(params, options) {
     const { modelId, documents, chunk, chunkOpts, workspace, progressInterval } = ragIngestParamsSchema.parse(params);

package/dist/server/bare/rag-hyperdb/handlers/search.js

@@ -1,5 +1,5 @@
 import { getRagInstance, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
-import { embed } from "../../addons/llamacpp-embedding/index.js";
+import { embed } from "../../ops/embed.js";
 import { ragSearchParamsSchema } from "../../../../schemas/index.js";
 export async function search(params) {
     const { modelId, query, topK, n, workspace } = ragSearchParamsSchema.parse(params);

package/dist/server/bare/rag-hyperdb/rag-workspace-manager.js

@@ -4,6 +4,7 @@ import fs, { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getConfiguredCacheDir } from "../registry/config-registry.js";
 import { RAGWorkspaceModelMismatchError, RAGWorkspaceNotOpenError, } from "../../../utils/errors-server.js";
+import { validateAndJoinPath } from "../../utils/path-security.js";
 import { createStreamLogger, getServerLogger, ADDON_NAMESPACES, } from "../../../logging/index.js";
 import { cancelAllRagOperations } from "./rag-operation-manager.js";
 const logger = getServerLogger();
@@ -17,7 +18,7 @@ function getRagBaseDir() {
     return path.join(path.dirname(cacheDir), "rag-hyperdb");
 }
 function getStorePath(workspace) {
-    return path.join(getRagBaseDir(), workspace);
+    return validateAndJoinPath(getRagBaseDir(), workspace);
 }
 export function hasRagWorkspaceStorage(workspace) {
     const key = getWorkspaceKey(workspace);

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 "../../worker.js";
+import { getEnv } from "../../env.js";
 import { CacheDirNotAbsoluteError, CacheDirNotWritableError, ConfigAlreadySetError, } from "../../../utils/errors-server.js";
 import { getServerLogger, setGlobalConsoleOutput, setGlobalLogLevel, } from "../../../logging/index.js";
 const logger = getServerLogger();

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

@@ -39,17 +39,6 @@ export const BUILTIN_DEVICE_PATTERNS = [
             [ModelType.llamacppEmbedding]: { device: "cpu" },
         },
     },
-    {
-        name: "iPhone 17",
-        match: {
-            platform: "ios",
-            deviceModelPrefix: "iPhone 17",
-        },
-        defaults: {
-            [ModelType.llamacppCompletion]: { device: "cpu" },
-            [ModelType.llamacppEmbedding]: { device: "cpu" },
-        },
-    },
 ];
 export function matchesPattern(ctx, match) {
     if (match.platform !== undefined && ctx.platform !== match.platform) {

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

@@ -0,0 +1,5 @@
+import { QVACRegistryClient } from "@qvac/registry-client";
+export declare function getRegistryClient(): Promise<QVACRegistryClient>;
+export declare function closeRegistryClient(): Promise<void>;
+export declare function hasActiveRegistryClient(): boolean;
+//# sourceMappingURL=registry-client.d.ts.map

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

@@ -0,0 +1,37 @@
+import { QVACRegistryClient } from "@qvac/registry-client";
+import { getCacheDir } from "../../utils/cache.js";
+import { getServerLogger } from "../../../logging/index.js";
+import { DEFAULT_REGISTRY_CORE_KEY } from "../../../constants/index.js";
+const logger = getServerLogger();
+let registryClient = null;
+export async function getRegistryClient() {
+    if (registryClient) {
+        logger.debug("Registry client reused");
+        return registryClient;
+    }
+    logger.info("🔗 Creating new registry client...");
+    registryClient = new QVACRegistryClient({
+        registryCoreKey: DEFAULT_REGISTRY_CORE_KEY,
+        storage: getCacheDir(`registry-corestore/${DEFAULT_REGISTRY_CORE_KEY}`),
+    });
+    await registryClient.ready();
+    logger.info("✅ Registry client ready");
+    return registryClient;
+}
+export async function closeRegistryClient() {
+    if (!registryClient)
+        return;
+    const client = registryClient;
+    registryClient = null;
+    logger.info("🔌 Closing registry client...");
+    try {
+        await client.close();
+        logger.info("✅ Registry client closed");
+    }
+    catch (error) {
+        logger.error("❌ Error closing registry client:", error instanceof Error ? error.message : String(error));
+    }
+}
+export function hasActiveRegistryClient() {
+    return registryClient !== null;
+}

package/dist/server/env.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Initialize the worker environment. Call once at worker startup.
+ * Returns whether RPC config was parsed from arguments.
+ */
+export declare function initEnv(): {
+    hasRPCConfig: boolean;
+};
+/**
+ * Get the worker environment. Must call initEnv() first.
+ */
+export declare function getEnv(): {
+    HOME_DIR: string;
+    QVAC_IPC_SOCKET_PATH?: string | undefined;
+};
+/**
+ * Get the validated env config. Must call initEnv() first.
+ */
+export declare function getValidatedEnv(): {
+    HOME_DIR: string;
+    QVAC_IPC_SOCKET_PATH?: string | undefined;
+};
+//# sourceMappingURL=env.d.ts.map

package/dist/server/env.js

@@ -0,0 +1,57 @@
+import process from "bare-process";
+import { isBareKit } from "which-runtime";
+import { z } from "zod";
+const envSchema = z.object({
+    QVAC_IPC_SOCKET_PATH: z.string().optional(),
+    HOME_DIR: z.string(),
+});
+let validatedEnv = null;
+/**
+ * Initialize the worker environment. Call once at worker startup.
+ * Returns whether RPC config was parsed from arguments.
+ */
+export function initEnv() {
+    const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
+    let envConfig = {
+        HOME_DIR: defaultHomeDir,
+    };
+    let hasRPCConfig = false;
+    if (isBareKit && process.argv[0]) {
+        envConfig["HOME_DIR"] = process.argv[0];
+    }
+    // Try to parse any argument as JSON config (fail gracefully)
+    if (process.argv[2]) {
+        try {
+            const rpcArgs = JSON.parse(process.argv[2]);
+            envConfig = { ...envConfig, ...rpcArgs };
+            hasRPCConfig = true;
+        }
+        catch {
+            // Not JSON or invalid - use defaults (direct mode)
+        }
+    }
+    validatedEnv = envSchema.parse(envConfig);
+    return { hasRPCConfig };
+}
+/**
+ * Get the worker environment. Must call initEnv() first.
+ */
+export function getEnv() {
+    if (!validatedEnv) {
+        // Fallback initialization for cases where initEnv wasn't called
+        initEnv();
+    }
+    return {
+        ...process.env,
+        ...validatedEnv,
+    };
+}
+/**
+ * Get the validated env config. Must call initEnv() first.
+ */
+export function getValidatedEnv() {
+    if (!validatedEnv) {
+        initEnv();
+    }
+    return validatedEnv;
+}

package/dist/server/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/index.js

@@ -0,0 +1 @@
+export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";

package/dist/server/plugins/registry.d.ts

@@ -0,0 +1,9 @@
+import { type QvacPlugin, type PluginHandlerDefinition } from "../../schemas/plugin";
+export declare function registerPlugin(plugin: QvacPlugin): void;
+export declare function getPlugin(modelType: string): QvacPlugin | undefined;
+export declare function getPluginHandler(modelType: string, handlerName: string): PluginHandlerDefinition | undefined;
+export declare function hasPlugin(modelType: string): boolean;
+export declare function unregisterPlugin(modelType: string): boolean;
+export declare function getAllPlugins(): QvacPlugin[];
+export declare function clearPlugins(): void;
+//# sourceMappingURL=registry.d.ts.map