@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/examples/whispercpp-microphone-record.js

@@ -0,0 +1,311 @@
+import { loadModel, downloadAsset, unloadModel, transcribe, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2, } from "@qvac/sdk";
+import { spawn, spawnSync } from "child_process";
+import * as readline from "readline";
+import { platform } from "os";
+function checkFFmpegAvailable() {
+    try {
+        const result = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+        if (result.error || result.status !== 0) {
+            throw new Error("FFmpeg not available");
+        }
+    }
+    catch {
+        throw new Error("FFmpeg is not installed or not available in PATH. Please install FFmpeg to use microphone recording.");
+    }
+}
+function getAudioDevice(platformName) {
+    switch (platformName) {
+        case "darwin":
+            return ":0";
+        case "win32":
+            // Change as per your system
+            return "audio=@device_cm_{33D9A762-90C8-11D0-BD43-00A0C911CE86}\\wave_{58C07110-A4FD-4FF8-BA10-5A3C14389F71}";
+        case "linux":
+            return "default";
+        default:
+            throw new Error(`Unsupported platform for audio recording: ${platformName}`);
+    }
+}
+// Parse command line arguments
+const args = process.argv.slice(2);
+const isStreamingMode = args.includes("--stream");
+// Show help if needed
+if (args.includes("--help") || args.includes("-h")) {
+    console.log("🎤 Microphone Transcription Demo");
+    console.log("");
+    console.log("Usage:");
+    console.log("  bun run examples/microphone-record-transcription.ts [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  --stream              Enable real-time streaming transcription");
+    console.log("  --help, -h            Show this help message");
+    console.log("");
+    console.log("Default behavior: Record audio, then transcribe when you stop recording");
+    console.log("With --stream: Transcribe audio in real-time as you speak");
+    process.exit(0);
+}
+// Clean readline-based transcription session
+function startInteractiveSession(rl, modelId) {
+    let isRecording = false;
+    let ffmpeg = null;
+    let audioBuffer = Buffer.alloc(0);
+    let audioChunkBuffer = Buffer.alloc(0);
+    const chunkSizeBytes = 96000; // ~3 seconds of audio at 16kHz 16-bit mono
+    let lastProcessTime = 0;
+    const showInstructions = () => {
+        if (isStreamingMode) {
+            console.log("🎤 Real-Time Transcription Session");
+            console.log("📊 Format: 16kHz, 32-bit float, mono, f32le");
+            console.log(`🎙️  Using ${platform() === "darwin" ? "macOS" : platform() === "win32" ? "Windows" : "Linux"} microphone`);
+            console.log("⏯️  Press Enter to START/STOP real-time transcription");
+            console.log("🛑 Type 'q' and press Enter to quit");
+        }
+        else {
+            console.log("🎤 Record-and-Transcribe Session");
+            console.log("📊 Format: 16kHz, 32-bit float, mono, f32le");
+            console.log(`🎙️  Using ${platform() === "darwin" ? "macOS" : platform() === "win32" ? "Windows" : "Linux"} microphone`);
+            console.log("⏯️  Press Enter to START/STOP recording");
+            console.log("🛑 Type 'q' and press Enter to quit");
+        }
+        console.log("");
+    };
+    const startRecording = () => {
+        if (isStreamingMode) {
+            console.log("🔴 Starting real-time transcription...");
+            audioChunkBuffer = Buffer.alloc(0);
+            console.log("\n" + "═".repeat(80));
+            console.log("🗣️  REAL-TIME TRANSCRIPTION");
+            console.log("═".repeat(80));
+            console.log("📝 Speak now, transcription will appear as you talk...");
+            console.log("");
+        }
+        else {
+            console.log("🔴 Starting recording...");
+            audioBuffer = Buffer.alloc(0);
+        }
+        const currentPlatform = platform();
+        const audioInputArgs = (() => {
+            switch (currentPlatform) {
+                case "darwin":
+                    return ["-f", "avfoundation", "-i", getAudioDevice(currentPlatform)];
+                case "win32":
+                    return ["-f", "dshow", "-i", getAudioDevice(currentPlatform)];
+                case "linux":
+                    return ["-f", "pulse", "-i", getAudioDevice(currentPlatform)];
+                default:
+                    throw new Error(`Unsupported platform for audio recording: ${currentPlatform}`);
+            }
+        })();
+        ffmpeg = spawn("ffmpeg", [
+            ...audioInputArgs,
+            "-ar",
+            "16000", // 16kHz
+            "-ac",
+            "1", // Mono
+            "-sample_fmt",
+            "flt", // 32-bit float
+            "-f",
+            "f32le", // f32le output format
+            "pipe:1", // Output to stdout
+        ], { stdio: ["ignore", "pipe", "ignore"] });
+        if (!ffmpeg.stdout) {
+            console.error("Failed to create microphone stream");
+            return;
+        }
+        if (isStreamingMode) {
+            // Process audio chunks in real-time
+            ffmpeg.stdout.on("data", (chunk) => {
+                audioChunkBuffer = Buffer.concat([audioChunkBuffer, chunk]);
+                const now = Date.now();
+                if (audioChunkBuffer.length >= chunkSizeBytes &&
+                    now - lastProcessTime > 1000) {
+                    const chunkToProcess = audioChunkBuffer.slice(0, chunkSizeBytes);
+                    audioChunkBuffer = audioChunkBuffer.slice(chunkSizeBytes);
+                    lastProcessTime = now;
+                    if (chunkToProcess.length < 32000)
+                        return;
+                    void (async () => {
+                        try {
+                            for await (const textChunk of transcribeStream({
+                                modelId,
+                                audioChunk: chunkToProcess,
+                            })) {
+                                if (textChunk.trim() && !textChunk.includes("[BLANK_AUDIO]")) {
+                                    process.stdout.write(textChunk);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            console.error("\n⚠️  Transcription error:", error instanceof Error ? error.message : String(error));
+                        }
+                    })();
+                }
+            });
+        }
+        else {
+            // Buffer all audio data for later transcription
+            ffmpeg.stdout.on("data", (chunk) => {
+                audioBuffer = Buffer.concat([audioBuffer, chunk]);
+            });
+        }
+        isRecording = true;
+        if (isStreamingMode) {
+            console.log("✅ Real-time transcription active!");
+            console.log("⏹️  Press Enter to STOP");
+        }
+        else {
+            console.log("✅ Recording... speak now!");
+            console.log("⏹️  Press Enter to STOP and transcribe");
+        }
+    };
+    const stopRecording = async () => {
+        if (!isRecording)
+            return;
+        if (ffmpeg) {
+            ffmpeg.kill();
+        }
+        isRecording = false;
+        if (isStreamingMode) {
+            console.log("\n🛑 Stopping real-time transcription...");
+            if (audioChunkBuffer.length > 0) {
+                try {
+                    for await (const textChunk of transcribeStream({
+                        modelId,
+                        audioChunk: audioChunkBuffer,
+                    })) {
+                        if (textChunk.trim() && !textChunk.includes("[BLANK_AUDIO]")) {
+                            process.stdout.write(textChunk);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("\n❌ Final transcription failed:", error instanceof Error ? error.message : String(error));
+                }
+            }
+            console.log("\n═".repeat(80));
+            console.log("✅ Real-time transcription stopped");
+            console.log("⏯️  Press Enter to start again...");
+        }
+        else {
+            console.log("🛑 Stopping recording...");
+            console.log(`📦 Recorded ${audioBuffer.length} bytes of audio`);
+            console.log("🔄 Transcribing...");
+            const startTime = Date.now();
+            console.log("\n" + "═".repeat(80));
+            console.log("🗣️  TRANSCRIPTION RESULT");
+            console.log("═".repeat(80));
+            try {
+                const text = await transcribe({ modelId, audioChunk: audioBuffer });
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                console.log(`📝 "${text}"`);
+                console.log("═".repeat(80));
+                console.log(`✅ Transcription completed in ${elapsed}s`);
+                console.log("\n⏯️  Press Enter to record again...");
+            }
+            catch (error) {
+                console.error("\n❌ Transcription failed:", error instanceof Error ? error.message : String(error));
+                console.log("\n⏯️  Press Enter to record again...");
+            }
+        }
+    };
+    showInstructions();
+    const handleInput = (input) => {
+        const command = input.trim().toLowerCase();
+        if (command === "") {
+            // Just pressed Enter - toggle recording
+            if (isRecording) {
+                void stopRecording();
+            }
+            else {
+                startRecording();
+            }
+        }
+        else if (command === "q") {
+            console.log("\n🛑 Exiting...");
+            if (ffmpeg) {
+                ffmpeg.kill();
+            }
+            rl.close();
+            return;
+        }
+        else {
+            console.log(`❓ Unknown command: ${command}`);
+            console.log("💡 Press Enter to start/stop, 'q' to quit");
+        }
+        rl.prompt();
+    };
+    rl.on("line", handleInput);
+    rl.on("close", () => {
+        if (ffmpeg) {
+            ffmpeg.kill();
+        }
+        process.exit(0);
+    });
+    rl.prompt();
+}
+async function main() {
+    let modelId = null;
+    let rl = null;
+    // Set up readline interface FIRST to keep event loop alive during model loading
+    rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        if (isStreamingMode) {
+            console.log("🎤 Streaming Transcription Microphone Demo");
+            console.log("✨ Mode: Real-time streaming transcription");
+        }
+        else {
+            console.log("🎤 Record-and-Transcribe Microphone Demo");
+            console.log("✨ Mode: Record first, then transcribe");
+            console.log("💡 Tip: Use --stream flag for real-time transcription");
+        }
+        console.log("⚠️  Requirements:");
+        console.log("   - Microphone connected and accessible");
+        console.log("   - FFmpeg installed");
+        // Check FFmpeg availability
+        checkFFmpegAvailable();
+        // Download VAD model (asset download only - doesn't load into memory)
+        console.log("\n📥 Ensuring VAD model is available...");
+        await downloadAsset({ assetSrc: VAD_SILERO_5_1_2 });
+        // Load the Whisper model with VAD
+        console.log("\n📥 Loading Whisper model...");
+        modelId = await loadModel({
+            modelSrc: WHISPER_TINY,
+            modelType: "whisper",
+            modelConfig: {
+                mode: "caption",
+                update_frequency: "on_end",
+                audio_format: "f32le",
+            },
+            onProgress: (progress) => {
+                console.log(progress);
+            },
+        });
+        console.log(`✅ Whisper model loaded with ID: ${modelId}`);
+        // Start interactive session using the existing readline interface
+        console.log("\n🎧 Starting interactive session...");
+        startInteractiveSession(rl, modelId);
+    }
+    catch (error) {
+        console.error("❌ Error during transcription setup:", error instanceof Error ? error.message : String(error));
+        // Clean up on error
+        if (rl) {
+            rl.close();
+        }
+        if (modelId) {
+            console.log("\n🧹 Unloading Whisper model...");
+            await unloadModel({ modelId });
+            console.log("✅ Whisper model unloaded successfully");
+        }
+        process.exit(1);
+    }
+}
+// Handle graceful shutdown
+process.on("SIGINT", () => {
+    console.log("\n🛑 Stopping microphone transcription...");
+    process.exit(0);
+});
+// Start the application
+main().catch(console.error);

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

@@ -0,0 +1,5 @@
+export { default as withMobileBundle } from "./withMobileBundle";
+export { default as withOpenCL } from "./withOpenCL";
+export { default as withQvacSDK } from "./withQvacSDK";
+export { default } from "./withQvacSDK";
+//# sourceMappingURL=index.d.ts.map

package/dist/expo/plugins/index.js

@@ -0,0 +1,5 @@
+export { default as withMobileBundle } from "./withMobileBundle.js";
+export { default as withOpenCL } from "./withOpenCL.js";
+export { default as withQvacSDK } from "./withQvacSDK.js";
+// Export the main plugin as default for easy usage
+export { default } from "./withQvacSDK.js";

package/dist/expo/plugins/withMobileBundle.d.ts

@@ -0,0 +1,8 @@
+import type { ExpoConfig } from "expo/config";
+/**
+ * Expo plugin that automatically generates the mobile worker bundle during build
+ * using the user's installed bare library versions.
+ */
+declare function withMobileBundle(config: ExpoConfig): ExpoConfig;
+export default withMobileBundle;
+//# sourceMappingURL=withMobileBundle.d.ts.map

package/dist/expo/plugins/withMobileBundle.js

@@ -0,0 +1,60 @@
+import configPlugins from "@expo/config-plugins";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+const { withDangerousMod } = configPlugins;
+/**
+ * Expo plugin that automatically generates the mobile worker bundle during build
+ * using the user's installed bare library versions.
+ */
+function withMobileBundle(config) {
+    function buildMobileBundle(config) {
+        console.log("🕚 QVAC: Generating mobile worker bundle with current dependencies...");
+        const projectRoot = config.modRequest.projectRoot;
+        const qvacSdkPath = path.join(projectRoot, "node_modules", "@qvac/sdk");
+        // Ensure package exists
+        if (!fs.existsSync(qvacSdkPath)) {
+            throw new Error("@qvac/sdk not found in node_modules");
+        }
+        const workerPath = path.join(qvacSdkPath, "dist", "server", "worker.js");
+        const outputPath = path.join(qvacSdkPath, "dist/worker.mobile.bundle.js");
+        // Check if worker.js exists
+        if (!fs.existsSync(workerPath)) {
+            throw new Error(`Worker file not found at ${workerPath}`);
+        }
+        try {
+            // Truncate incompatible RPC clients for mobile (keep only rpc-client.js and expo-rpc-client.js)
+            const rpcClientsToTruncate = [
+                "node-rpc-client.js",
+                "bare-rpc-client.js",
+                "bare-client.js",
+            ];
+            const truncatedContent = "// This RPC client is not available in mobile environments";
+            for (const clientFile of rpcClientsToTruncate) {
+                const clientPath = path.join(qvacSdkPath, "dist", "client", "rpc", clientFile);
+                if (fs.existsSync(clientPath)) {
+                    fs.writeFileSync(clientPath, truncatedContent);
+                    console.log(`🔧 QVAC: Truncated ${clientFile} for mobile compatibility`);
+                }
+            }
+            // Remove optional modules from the bundle
+            const optionalModules = ["crypto"];
+            const deferFlags = optionalModules
+                .map((mod) => `--defer "${mod}"`)
+                .join(" ");
+            // Generate the bundle using bun bare-pack with the current project's dependencies
+            // We use the project root as working directory so bare-pack uses the user's node_modules
+            execSync(`cd "${projectRoot}" && npx bare-pack --target android-arm64 --target ios-arm64 --target ios-arm64-simulator --linked ${deferFlags} --out "${outputPath}" "${workerPath}"`, { stdio: "inherit", cwd: projectRoot });
+            console.log("🫡 QVAC: Mobile worker bundle generated successfully");
+        }
+        catch (error) {
+            console.error("❌ QVAC: Failed to generate mobile worker bundle:", error);
+            throw error;
+        }
+        return config;
+    }
+    config = withDangerousMod(config, ["android", buildMobileBundle]);
+    config = withDangerousMod(config, ["ios", buildMobileBundle]);
+    return config;
+}
+export default withMobileBundle;

package/dist/expo/plugins/withOpenCL.d.ts

@@ -0,0 +1,9 @@
+import type { ExpoConfig } from "expo/config";
+/**
+ * Plugin to add OpenCL native library support to Android build
+ * This plugin was written by the most helpful folk in the QVAC team: Luis Moromisato.
+ * Thank you Luis!
+ */
+declare function withOpenCL(config: ExpoConfig): ExpoConfig;
+export default withOpenCL;
+//# sourceMappingURL=withOpenCL.d.ts.map

package/dist/expo/plugins/withOpenCL.js

@@ -0,0 +1,118 @@
+import configPlugins from "@expo/config-plugins";
+const { withAndroidManifest, withAppBuildGradle } = configPlugins;
+/**
+ * Plugin to add OpenCL native library support to Android build
+ * This plugin was written by the most helpful folk in the QVAC team: Luis Moromisato.
+ * Thank you Luis!
+ */
+function withOpenCL(config) {
+    config = withOpenCLAndroidManifest(config);
+    config = withOpenCLBuildGradle(config);
+    return config;
+}
+/**
+ * Modify AndroidManifest.xml to include OpenCL native library
+ */
+function withOpenCLAndroidManifest(config) {
+    return withAndroidManifest(config, (config) => {
+        const androidManifest = config.modResults;
+        // Find the application element
+        const application = androidManifest.manifest.application?.[0];
+        if (application) {
+            // Type assertion for dynamic manifest properties
+            const appWithNativeLibs = application;
+            // Check if uses-native-library already exists
+            const existingNativeLib = appWithNativeLibs["uses-native-library"]?.find((lib) => lib.$["android:name"] === "libOpenCL.so");
+            if (!existingNativeLib) {
+                // Add uses-native-library if it doesn't exist
+                if (!appWithNativeLibs["uses-native-library"]) {
+                    appWithNativeLibs["uses-native-library"] = [];
+                }
+                appWithNativeLibs["uses-native-library"].push({
+                    $: {
+                        "android:name": "libOpenCL.so",
+                    },
+                });
+            }
+        }
+        return config;
+    });
+}
+/**
+ * Modify build.gradle to exclude OpenCL library from packaging
+ * FIXED VERSION: Properly handles existing packagingOptions blocks
+ */
+function withOpenCLBuildGradle(config) {
+    return withAppBuildGradle(config, (config) => {
+        let buildGradleContent = config.modResults.contents;
+        // Check if the exclusion already exists anywhere in the file
+        if (buildGradleContent.includes('excludes += "/lib/**/libOpenCL.so"')) {
+            console.log("[withOpenCL] OpenCL exclusion already exists in build.gradle");
+            return config;
+        }
+        // Find ALL packagingOptions blocks in the android block
+        const androidBlockMatch = buildGradleContent.match(/android\s*{([\s\S]*?)^}/m);
+        if (!androidBlockMatch) {
+            console.error("[withOpenCL] Could not find android block in build.gradle");
+            return config;
+        }
+        const androidBlockContent = androidBlockMatch[1];
+        // Check if there's already a packagingOptions block with jniLibs
+        const existingJniLibsMatch = androidBlockContent?.match(/packagingOptions\s*{[\s\S]*?jniLibs\s*{[\s\S]*?}/g);
+        if (existingJniLibsMatch && existingJniLibsMatch.length > 0) {
+            // Find the FIRST packagingOptions block with jniLibs and modify it
+            // This ensures we don't create duplicate blocks
+            const firstJniLibsBlockRegex = /(packagingOptions\s*{[\s\S]*?jniLibs\s*{[\s\S]*?)(})/;
+            buildGradleContent = buildGradleContent.replace(firstJniLibsBlockRegex, (match, before, closing) => {
+                // Check if this specific block already has the exclusion
+                if (match.includes('excludes += "/lib/**/libOpenCL.so"')) {
+                    return match;
+                }
+                // Add the exclusion before the closing brace of jniLibs
+                return (before +
+                    '            excludes += "/lib/**/libOpenCL.so"\n        ' +
+                    closing);
+            });
+            console.log("[withOpenCL] Added OpenCL exclusion to existing packagingOptions block");
+        }
+        else {
+            // No existing packagingOptions with jniLibs found
+            // Check if there's ANY packagingOptions block
+            const anyPackagingOptionsMatch = androidBlockContent?.match(/packagingOptions\s*{[\s\S]*?}/);
+            if (anyPackagingOptionsMatch) {
+                // Add jniLibs section to existing packagingOptions
+                const packagingOptionsRegex = /(packagingOptions\s*{)([\s\S]*?)(^\s*})/m;
+                buildGradleContent = buildGradleContent.replace(packagingOptionsRegex, (_, opening, content, closing) => {
+                    const jniLibsSection = `
+        jniLibs {
+            def enableLegacyPackaging = findProperty('expo.useLegacyPackaging') ?: 'false'
+            useLegacyPackaging enableLegacyPackaging.toBoolean()
+            excludes += "/lib/**/libOpenCL.so"
+        }`;
+                    return opening + content + jniLibsSection + "\n" + closing;
+                });
+                console.log("[withOpenCL] Added jniLibs section to existing packagingOptions block");
+            }
+            else {
+                // No packagingOptions at all, add a new one before the closing of android block
+                const androidBlockRegex = /(android\s*{[\s\S]*?)(^})/m;
+                buildGradleContent = buildGradleContent.replace(androidBlockRegex, (_, before, closing) => {
+                    const packagingConfig = `
+    packagingOptions {
+        jniLibs {
+            def enableLegacyPackaging = findProperty('expo.useLegacyPackaging') ?: 'false'
+            useLegacyPackaging enableLegacyPackaging.toBoolean()
+            excludes += "/lib/**/libOpenCL.so"
+        }
+    }
+`;
+                    return before + packagingConfig + closing;
+                });
+                console.log("[withOpenCL] Added new packagingOptions block with OpenCL exclusion");
+            }
+        }
+        config.modResults.contents = buildGradleContent;
+        return config;
+    });
+}
+export default withOpenCL;

package/dist/expo/plugins/withQvacSDK.d.ts

@@ -0,0 +1,9 @@
+import type { ExpoConfig } from "expo/config";
+/**
+ * Main Qvac SDK Expo plugin that combines all necessary mobile configurations:
+ * - Mobile worker bundle generation
+ * - OpenCL native library support for Android
+ */
+declare function withQvacSDK(config: ExpoConfig): ExpoConfig;
+export default withQvacSDK;
+//# sourceMappingURL=withQvacSDK.d.ts.map

package/dist/expo/plugins/withQvacSDK.js

@@ -0,0 +1,13 @@
+import configPlugins from "@expo/config-plugins";
+import withMobileBundle from "./withMobileBundle.js";
+import withOpenCL from "./withOpenCL.js";
+const { withPlugins } = configPlugins;
+/**
+ * Main Qvac SDK Expo plugin that combines all necessary mobile configurations:
+ * - Mobile worker bundle generation
+ * - OpenCL native library support for Android
+ */
+function withQvacSDK(config) {
+    return withPlugins(config, [withMobileBundle, withOpenCL]);
+}
+export default withQvacSDK;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index";
+export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, } from "./schemas/index";
+export * from "./models/hyperdrive/index";
+export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";
+export { getLogger, setGlobalLogLevel } from "./logging/index";
+export type { Logger, LogTransport, LoggerOptions } from "./logging/index";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,8 @@
+// Public API exports only
+export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index.js";
+export { VERBOSITY, } from "./schemas/index.js";
+// Hyperdrive model constants
+export * from "./models/hyperdrive/index.js";
+export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio.js";
+// Logging exports
+export { getLogger, setGlobalLogLevel } from "./logging/index.js";

package/dist/logging/base-logger.d.ts

@@ -0,0 +1,7 @@
+import { type LogLevel } from "@qvac/logging";
+import type { Logger, LoggerOptions } from "./types";
+export interface LoggerExtensions {
+    onLog?: (level: LogLevel, namespace: string, message: string) => void;
+}
+export declare function createBaseLogger(namespace: string, options?: LoggerOptions, extensions?: LoggerExtensions): Logger;
+//# sourceMappingURL=base-logger.d.ts.map

package/dist/logging/base-logger.js

@@ -0,0 +1,55 @@
+import QvacLogger, {} from "@qvac/logging";
+import { LOG_LEVELS } from "@qvac/logging/constants.js";
+import { isLevelEnabled, formatArg } from "./utils.js";
+export function createBaseLogger(namespace, options, extensions) {
+    const qvacLogger = new QvacLogger(console);
+    const initialLevel = options?.level ?? LOG_LEVELS.INFO;
+    qvacLogger.setLevel(initialLevel);
+    const transports = options?.transports || [];
+    const log = (level, ...args) => {
+        if (!isLevelEnabled(level, qvacLogger.getLevel())) {
+            return;
+        }
+        const message = args.map(formatArg).join(" ");
+        switch (level) {
+            case LOG_LEVELS.ERROR:
+                qvacLogger.error(`[${namespace}]`, ...args);
+                break;
+            case LOG_LEVELS.WARN:
+                qvacLogger.warn(`[${namespace}]`, ...args);
+                break;
+            case LOG_LEVELS.INFO:
+                qvacLogger.info(`[${namespace}]`, ...args);
+                break;
+            case LOG_LEVELS.DEBUG:
+                qvacLogger.debug(`[${namespace}]`, ...args);
+                break;
+        }
+        extensions?.onLog?.(level, namespace, message);
+        for (const transport of transports) {
+            try {
+                const result = transport(level, namespace, message);
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        console.error(`Transport error in ${namespace}:`, error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Transport error in ${namespace}:`, error);
+            }
+        }
+    };
+    return {
+        error: (...args) => log(LOG_LEVELS.ERROR, ...args),
+        warn: (...args) => log(LOG_LEVELS.WARN, ...args),
+        info: (...args) => log(LOG_LEVELS.INFO, ...args),
+        debug: (...args) => log(LOG_LEVELS.DEBUG, ...args),
+        trace: (...args) => log(LOG_LEVELS.DEBUG, ...args),
+        setLevel: (level) => qvacLogger.setLevel(level),
+        getLevel: () => qvacLogger.getLevel(),
+        addTransport: (transport) => {
+            transports.push(transport);
+        },
+    };
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,4 @@
+export { getLogger, setGlobalLogLevel } from "./logger";
+export { createStreamLogger } from "./stream-logger";
+export type { Logger, LoggerOptions, LogTransport } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -0,0 +1,2 @@
+export { getLogger, setGlobalLogLevel } from "./logger.js";
+export { createStreamLogger } from "./stream-logger.js";

package/dist/logging/logger.d.ts

@@ -0,0 +1,5 @@
+import type { LogLevel } from "@qvac/logging";
+import type { Logger, LoggerOptions } from "./types";
+export declare function getLogger(namespace: string, options?: LoggerOptions): Logger;
+export declare function setGlobalLogLevel(level: LogLevel): void;
+//# sourceMappingURL=logger.d.ts.map