pi-ui-extend 1.0.42 → 1.0.45

package/dist/app/input/voice-controller.js

@@ -1,29 +1,24 @@
 import { spawn } from "node:child_process";
-import { createWriteStream } from "node:fs";
-import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import http from "node:http";
-import https from "node:https";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { pipeline } from "node:stream/promises";
-import { fileURLToPath } from "node:url";
-import { savePixDictationLanguage } from "../../config.js";
+import { savePixDictationLanguage, } from "../../config.js";
 import { APP_ICONS } from "../icons.js";
 import { commandExists } from "../process.js";
 const SAMPLE_RATE = 16_000;
-const require = createRequire(import.meta.url);
-const projectRoot = fileURLToPath(new URL("../..", import.meta.url));
-const modelsRoot = join(projectRoot, "models", "vosk");
-const VOSK_PACKAGE_SPEC = "vosk@0.3.39";
+const DEEPGRAM_SOCKET_OPEN = 1;
+const DEEPGRAM_SOCKET_CONNECT_TIMEOUT_MS = 10_000;
+const RECORDER_STOP_GRACE_MS = 150;
+const RECORDER_FORCE_STOP_GRACE_MS = 50;
+const DEEPGRAM_FINALIZE_GRACE_MS = 300;
+const DEFAULT_DEEPGRAM_MODEL = "nova-3";
 const VOICE_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS = 100;
-let voskInstallPromise;
 const defaultVoiceControllerDeps = {
-    tryLoadVosk,
-    ensureModel,
+    deepgramApiKey: () => process.env.DEEPGRAM_API_KEY?.trim() || undefined,
+    createDeepgramSocket,
+    waitForSocketOpen,
     selectRecorderCommand,
     spawn,
     savePixDictationLanguage,
+    delay,
 };
 let voiceControllerDeps = defaultVoiceControllerDeps;
 export function setVoiceControllerTestDeps(overrides) {
@@ -31,13 +26,14 @@ export function setVoiceControllerTestDeps(overrides) {
 }
 export class AppVoiceController {
     host;
-    modelDefinitions;
+    languageDefinitions;
     languages;
     language;
+    deepgramModel;
+    deepgramApiKey;
     state = "idle";
-    modelCache = new Map();
     audioProcess;
-    recognizer;
+    socket;
     progressMessage;
     progressFrame = 0;
     progressTimer;
@@ -46,35 +42,28 @@ export class AppVoiceController {
     partialTranscriptTimer;
     startGeneration = 0;
     recordingScope;
+    stopPromise;
+    disposed = false;
     constructor(host, dictationConfig) {
         this.host = host;
-        this.modelDefinitions = dictationConfig.languages;
-        this.languages = Object.keys(this.modelDefinitions);
+        this.languageDefinitions = dictationConfig.languages;
+        this.languages = Object.keys(this.languageDefinitions);
         this.language = this.initialLanguage(dictationConfig.language);
+        this.deepgramModel = dictationConfig.model?.trim() || DEFAULT_DEEPGRAM_MODEL;
+        this.deepgramApiKey = dictationConfig.apiKey?.trim() || undefined;
     }
     updateDictationConfig(dictationConfig) {
-        this.modelDefinitions = dictationConfig.languages;
-        this.languages = Object.keys(this.modelDefinitions);
+        this.languageDefinitions = dictationConfig.languages;
+        this.languages = Object.keys(this.languageDefinitions);
         this.language = this.initialLanguage(dictationConfig.language ?? this.language);
-        for (const language of this.modelCache.keys()) {
-            if (!this.modelDefinitions[language])
-                this.modelCache.delete(language);
-        }
+        this.deepgramModel = dictationConfig.model?.trim() || DEFAULT_DEEPGRAM_MODEL;
+        this.deepgramApiKey = dictationConfig.apiKey?.trim() || undefined;
     }
     statusWidgetText() {
         const languageLabel = this.showLanguageSwitcher() ? ` ${this.language.toUpperCase()}` : "";
-        switch (this.state) {
-            case "installing":
-                return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
-            case "downloading":
-                return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
-            case "loading":
-                return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
-            case "listening":
-                return `${APP_ICONS.microphone}${languageLabel}`;
-            case "idle":
-                return `${APP_ICONS.microphone}${languageLabel}`;
-        }
+        return this.state === "connecting"
+            ? `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`
+            : `${APP_ICONS.microphone}${languageLabel}`;
     }
     showLanguageSwitcher() {
         return this.languages.length > 1;
@@ -89,6 +78,12 @@ export class AppVoiceController {
         return `${spinner} ${this.progressMessage}`;
     }
     async toggleRecording() {
+        if (this.disposed)
+            return;
+        if (this.stopPromise) {
+            await this.stopPromise;
+            return;
+        }
         if (this.state !== "idle") {
             await this.stopRecording();
             return;
@@ -96,152 +91,197 @@ export class AppVoiceController {
         await this.startRecording();
     }
     async toggleLanguage() {
-        if (!this.showLanguageSwitcher())
+        if (this.disposed || !this.showLanguageSwitcher())
+            return;
+        if (this.stopPromise) {
+            await this.stopPromise;
             return;
+        }
         const scope = this.host.activeInputScope();
-        const wasActive = this.state !== "idle";
-        if (wasActive)
+        const shouldRestart = this.state !== "idle";
+        if (shouldRestart)
             await this.stopRecording();
-        if (!this.isScopeActive(scope))
+        if (this.disposed || !this.isScopeActive(scope))
             return;
         this.language = this.nextLanguage();
         this.saveLanguageSelection(this.language);
-        this.host.showToast(`Voice language: ${this.modelDefinition(this.language).label}`, "info");
+        this.host.showToast(`Voice language: ${this.languageDefinition(this.language).label}`, "info");
         this.host.render();
-        if (wasActive)
+        if (shouldRestart)
             void this.startRecording();
     }
     async stopRecording() {
+        if (this.disposed)
+            return;
+        if (this.stopPromise)
+            return await this.stopPromise;
+        const stopping = Promise.resolve().then(() => this.stopRecordingNow());
+        this.stopPromise = stopping;
+        try {
+            await stopping;
+        }
+        finally {
+            if (this.stopPromise === stopping)
+                this.stopPromise = undefined;
+        }
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
         this.startGeneration += 1;
-        const scope = this.recordingScope;
         const audioProcess = this.audioProcess;
-        const recognizer = this.recognizer;
+        const socket = this.socket;
         this.audioProcess = undefined;
-        this.recognizer = undefined;
+        this.socket = undefined;
         this.recordingScope = undefined;
-        if (audioProcess && !audioProcess.killed)
-            audioProcess.kill("SIGTERM");
-        if (recognizer) {
-            this.clearPartialTranscript(scope);
-            this.emitTranscript(recognizer.finalResult(), scope);
-            recognizer.free?.();
-        }
-        if (this.state !== "idle") {
-            this.clearProgressMessage();
-            this.state = "idle";
-            if (this.isScopeActive(scope))
-                this.host.render();
+        this.clearProgressMessage();
+        this.partialTranscript = undefined;
+        if (this.partialTranscriptTimer) {
+            clearTimeout(this.partialTranscriptTimer);
+            this.partialTranscriptTimer = undefined;
         }
-    }
-    async dispose() {
-        await this.stopRecording();
-        for (const model of this.modelCache.values())
-            model.free?.();
-        this.modelCache.clear();
+        this.state = "idle";
+        if (audioProcess?.exitCode === null)
+            safeKillProcess(audioProcess, "SIGKILL");
+        if (socket)
+            safeCloseSocket(socket);
     }
     async startRecording() {
+        if (this.disposed)
+            return;
         const language = this.language;
         const scope = this.host.activeInputScope();
         const generation = this.startGeneration + 1;
         this.startGeneration = generation;
         this.recordingScope = scope;
+        this.state = "connecting";
+        this.setProgressMessage("Connecting to Deepgram...", generation, scope);
+        let socket;
         try {
-            const initialVosk = voiceControllerDeps.tryLoadVosk();
-            const vosk = initialVosk.ok
-                ? initialVosk.module
-                : await this.installAndLoadVosk(initialVosk.error, generation, scope);
-            if (!this.continueStart(generation, scope))
-                return;
-            vosk.setLogLevel?.(-1);
-            this.state = "downloading";
-            this.host.render();
-            const modelPath = await voiceControllerDeps.ensureModel(language, this.modelDefinition(language));
-            if (!this.continueStart(generation, scope))
-                return;
-            this.state = "loading";
-            this.host.render();
-            const model = this.cachedModel(language, modelPath, vosk);
+            const apiKey = this.deepgramApiKey ?? voiceControllerDeps.deepgramApiKey();
+            if (!apiKey) {
+                throw new Error("Deepgram API key is not configured; set dictation.apiKey in ~/.config/pi/pix.jsonc or DEEPGRAM_API_KEY");
+            }
             const recorder = await voiceControllerDeps.selectRecorderCommand();
             if (!this.continueStart(generation, scope))
                 return;
-            const recognizer = new vosk.Recognizer({ model, sampleRate: SAMPLE_RATE });
+            socket = voiceControllerDeps.createDeepgramSocket(buildDeepgramUrl(this.deepgramModel, this.deepgramLanguage(language), true), ["token", apiKey]);
+            this.socket = socket;
+            await voiceControllerDeps.waitForSocketOpen(socket);
+            if (!this.continueStart(generation, scope) || this.socket !== socket) {
+                safeCloseSocket(socket);
+                return;
+            }
+            this.bindSocket(socket, generation, scope);
             const audioProcess = voiceControllerDeps.spawn(recorder.command, recorder.args, { stdio: ["ignore", "pipe", "pipe"] });
-            this.recognizer = recognizer;
             this.audioProcess = audioProcess;
+            this.clearProgressMessage();
             this.state = "listening";
             this.host.render();
-            this.host.showToast(`Voice input on (${this.modelDefinition(language).label}, ${recorder.description})`, "info");
-            this.bindAudioProcess(audioProcess, recognizer, generation, scope);
+            this.host.showToast(`Voice input on (${this.languageDefinition(language).label}, Deepgram ${this.deepgramModel})`, "info");
+            this.bindAudioProcess(audioProcess, socket, generation, scope);
         }
         catch (error) {
-            if (!this.continueStart(generation, scope))
+            if (!this.isCurrentStart(generation, scope)) {
+                if (socket)
+                    safeCloseSocket(socket);
                 return;
+            }
+            this.startGeneration += 1;
+            this.recordingScope = undefined;
+            this.audioProcess = undefined;
+            this.socket = undefined;
+            if (socket)
+                safeCloseSocket(socket);
+            this.clearPartialTranscript(scope);
             this.clearProgressMessage();
-            this.cleanupRecognizer();
             this.state = "idle";
             this.addProgressSystemMessage(`Unavailable: ${errorMessage(error)}`);
             this.host.showToast(`Voice input unavailable: ${errorMessage(error)}`, "error");
             this.host.render();
         }
     }
-    cachedModel(language, modelPath, vosk) {
-        const cached = this.modelCache.get(language);
-        if (cached)
-            return cached;
-        const model = new vosk.Model(modelPath);
-        this.modelCache.set(language, model);
-        return model;
-    }
-    nextLanguage() {
-        const currentIndex = this.languages.indexOf(this.language);
-        const nextIndex = currentIndex >= 0 ? (currentIndex + 1) % this.languages.length : 0;
-        return this.languages[nextIndex] ?? this.language;
-    }
-    initialLanguage(configuredLanguage) {
-        if (configuredLanguage && this.languages.includes(configuredLanguage))
-            return configuredLanguage;
-        return this.languages.includes("en") ? "en" : this.languages[0] ?? "en";
-    }
-    saveLanguageSelection(language) {
+    async stopRecordingNow() {
+        const scope = this.recordingScope;
+        const generation = this.startGeneration;
+        const audioProcess = this.audioProcess;
+        const socket = this.socket;
+        const wasListening = this.state === "listening";
+        this.clearProgressMessage();
+        this.state = "idle";
+        if (this.isScopeActive(scope))
+            this.host.render();
+        if (!wasListening || !socket || socket.readyState !== DEEPGRAM_SOCKET_OPEN) {
+            if (audioProcess?.exitCode === null)
+                safeKillProcess(audioProcess, "SIGKILL");
+            if (this.audioProcess === audioProcess)
+                this.audioProcess = undefined;
+            this.startGeneration += 1;
+            this.socket = undefined;
+            this.recordingScope = undefined;
+            this.clearPartialTranscript(scope);
+            if (socket)
+                safeCloseSocket(socket);
+            return;
+        }
+        if (audioProcess)
+            await stopRecorderProcess(audioProcess);
+        if (this.audioProcess === audioProcess)
+            this.audioProcess = undefined;
         try {
-            voiceControllerDeps.savePixDictationLanguage(language);
+            socket.send(JSON.stringify({ type: "Finalize" }));
         }
-        catch (error) {
-            this.host.showToast(`Could not save voice language: ${errorMessage(error)}`, "warning");
+        catch {
+            // Closing below still commits the most recent interim result.
         }
+        await voiceControllerDeps.delay(DEEPGRAM_FINALIZE_GRACE_MS);
+        if (this.startGeneration === generation && this.recordingScope === scope && this.socket === socket) {
+            this.commitPartialTranscript(scope);
+            this.startGeneration += 1;
+            this.socket = undefined;
+            this.recordingScope = undefined;
+        }
+        safeCloseSocket(socket);
     }
-    modelDefinition(language) {
-        const definition = this.modelDefinitions[language];
-        if (!definition)
-            throw new Error(`dictation language is not configured: ${language}`);
-        return definition;
-    }
-    async installAndLoadVosk(initialError, generation, scope) {
-        this.state = "installing";
-        this.setProgressMessage("Installing Vosk voice bindings...", generation, scope);
-        const vosk = await loadVoskWithAutoInstall(initialError, (message) => {
-            if (this.isCurrentStart(generation, scope))
-                this.setProgressMessage(message, generation, scope);
+    bindSocket(socket, generation, scope) {
+        socket.addEventListener("message", (event) => {
+            if (!this.isCurrentSocket(socket, generation, scope))
+                return;
+            const transcript = parseDeepgramTranscript(event.data);
+            if (!transcript)
+                return;
+            if (transcript.isFinal) {
+                this.clearPartialTranscript(scope);
+                this.host.insertTranscript(transcript.text);
+                return;
+            }
+            this.emitPartialTranscript(transcript.text, socket, generation, scope);
+        });
+        socket.addEventListener("error", () => {
+            if (!this.isCurrentSocket(socket, generation, scope) || this.state === "idle")
+                return;
+            this.host.showToast("Voice recognition failed: Deepgram WebSocket error", "error");
+            void this.stopRecording();
+        });
+        socket.addEventListener("close", (event) => {
+            if (!this.isCurrentSocket(socket, generation, scope) || this.state === "idle")
+                return;
+            const suffix = event.code && event.code !== 1000
+                ? ` (${event.code}${event.reason ? `: ${event.reason}` : ""})`
+                : "";
+            this.host.showToast(`Voice recognition stopped: Deepgram connection closed${suffix}`, "warning");
+            void this.stopRecording();
         });
-        if (this.isCurrentStart(generation, scope))
-            this.addProgressSystemMessage("Vosk voice bindings are ready.");
-        if (this.isCurrentStart(generation, scope))
-            this.clearProgressMessage();
-        return vosk;
     }
-    bindAudioProcess(audioProcess, recognizer, generation, scope = this.recordingScope) {
+    bindAudioProcess(audioProcess, socket, generation, scope) {
         let stderr = "";
         audioProcess.stdout.on("data", (chunk) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
+            if (!this.isCurrentAudioProcess(audioProcess, socket, generation, scope))
                 return;
             try {
-                if (recognizer.acceptWaveform(chunk)) {
-                    this.clearPartialTranscript(scope);
-                    this.emitTranscript(recognizer.result(), scope);
-                }
-                else {
-                    this.emitPartialTranscript(recognizer.partialResult?.(), audioProcess, recognizer, generation, scope);
-                }
+                if (socket.readyState === DEEPGRAM_SOCKET_OPEN)
+                    socket.send(chunk);
             }
             catch (error) {
                 this.host.showToast(`Voice recognition failed: ${errorMessage(error)}`, "error");
@@ -252,33 +292,51 @@ export class AppVoiceController {
             stderr = `${stderr}${chunk.toString("utf8")}`.slice(-600);
         });
         audioProcess.once("error", (error) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
+            if (!this.isCurrentAudioProcess(audioProcess, socket, generation, scope))
+                return;
+            if (this.state === "idle")
                 return;
-            this.clearPartialTranscript(scope);
-            this.cleanupRecognizer();
-            this.audioProcess = undefined;
-            this.state = "idle";
             this.host.showToast(`Voice recorder failed: ${errorMessage(error)}`, "error");
-            this.host.render();
+            void this.stopRecording();
         });
         audioProcess.once("close", (code, signal) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
+            if (!this.isCurrentAudioProcess(audioProcess, socket, generation, scope))
+                return;
+            if (this.state === "idle")
                 return;
-            this.clearPartialTranscript(scope);
-            this.emitTranscript(recognizer.finalResult(), scope);
-            this.cleanupRecognizer();
-            this.audioProcess = undefined;
-            this.state = "idle";
             if (code && code !== 0) {
                 const details = stderr.trim() || signal || `exit code ${code}`;
                 this.host.showToast(`Voice recorder stopped: ${details}`, "warning");
             }
-            this.host.render();
+            void this.stopRecording();
         });
     }
-    cleanupRecognizer() {
-        this.recognizer?.free?.();
-        this.recognizer = undefined;
+    nextLanguage() {
+        const currentIndex = this.languages.indexOf(this.language);
+        const nextIndex = currentIndex >= 0 ? (currentIndex + 1) % this.languages.length : 0;
+        return this.languages[nextIndex] ?? this.language;
+    }
+    initialLanguage(configuredLanguage) {
+        if (configuredLanguage && this.languages.includes(configuredLanguage))
+            return configuredLanguage;
+        return this.languages.includes("en") ? "en" : this.languages[0] ?? "en";
+    }
+    saveLanguageSelection(language) {
+        try {
+            voiceControllerDeps.savePixDictationLanguage(language);
+        }
+        catch (error) {
+            this.host.showToast(`Could not save voice language: ${errorMessage(error)}`, "warning");
+        }
+    }
+    languageDefinition(language) {
+        const definition = this.languageDefinitions[language];
+        if (!definition)
+            throw new Error(`dictation language is not configured: ${language}`);
+        return definition;
+    }
+    deepgramLanguage(language) {
+        return this.languageDefinition(language).deepgramLanguage?.trim() || language;
     }
     setProgressMessage(message, generation = this.startGeneration, scope = this.recordingScope) {
         this.progressMessage = message;
@@ -309,24 +367,13 @@ export class AppVoiceController {
         this.lastSystemProgressMessage = text;
         this.host.addSystemMessage(text);
     }
-    emitTranscript(result, scope = this.recordingScope) {
-        if (!this.isScopeActive(scope))
-            return;
-        const text = transcriptText(result);
-        if (!text)
+    emitPartialTranscript(text, socket = this.socket, generation = this.startGeneration, scope = this.recordingScope) {
+        if (socket && !this.isCurrentSocket(socket, generation, scope))
             return;
-        this.host.insertTranscript(text);
-    }
-    emitPartialTranscript(result, audioProcess = this.audioProcess, recognizer = this.recognizer, generation = this.startGeneration, scope = this.recordingScope) {
-        if (audioProcess || recognizer) {
-            if (!audioProcess || !recognizer || !this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
-                return;
-        }
-        const text = partialTranscriptText(result);
         if (text === this.partialTranscript)
             return;
         this.partialTranscript = text;
-        this.schedulePartialTranscriptEmit(audioProcess, recognizer, generation, scope);
+        this.schedulePartialTranscriptEmit(socket, generation, scope);
     }
     clearPartialTranscript(scope = this.recordingScope) {
         if (!this.partialTranscript)
@@ -339,18 +386,21 @@ export class AppVoiceController {
         if (this.isScopeActive(scope))
             this.host.setPartialTranscript(undefined);
     }
-    schedulePartialTranscriptEmit(audioProcess, recognizer, generation, scope) {
+    commitPartialTranscript(scope = this.recordingScope) {
+        const text = this.partialTranscript;
+        this.clearPartialTranscript(scope);
+        if (text && this.isScopeActive(scope))
+            this.host.insertTranscript(text);
+    }
+    schedulePartialTranscriptEmit(socket, generation, scope) {
         if (this.partialTranscriptTimer)
             return;
         this.partialTranscriptTimer = setTimeout(() => {
             this.partialTranscriptTimer = undefined;
-            if (audioProcess && recognizer) {
-                if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
-                    return;
-            }
-            else if (!this.isScopeActive(scope)) {
+            if (socket && !this.isCurrentSocket(socket, generation, scope))
+                return;
+            if (!this.isScopeActive(scope))
                 return;
-            }
             this.host.setPartialTranscript(this.partialTranscript);
         }, VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS);
         this.partialTranscriptTimer.unref?.();
@@ -365,256 +415,66 @@ export class AppVoiceController {
             return true;
         this.startGeneration += 1;
         this.recordingScope = undefined;
+        this.socket = undefined;
         this.clearProgressMessage();
         this.state = "idle";
         return false;
     }
-    isCurrentAudioProcess(audioProcess, recognizer, generation, scope = this.recordingScope) {
-        return this.isCurrentStart(generation, scope) && this.audioProcess === audioProcess && this.recognizer === recognizer;
+    isCurrentSocket(socket, generation, scope = this.recordingScope) {
+        return this.startGeneration === generation
+            && this.recordingScope === scope
+            && this.socket === socket
+            && this.isScopeActive(scope);
+    }
+    isCurrentAudioProcess(audioProcess, socket, generation, scope = this.recordingScope) {
+        return this.audioProcess === audioProcess && this.isCurrentSocket(socket, generation, scope);
     }
     isScopeActive(scope) {
         return this.host.activeInputScope() === scope;
     }
 }
-async function ensureModel(language, definition) {
-    const modelPath = join(modelsRoot, definition.dirName);
-    if (await looksLikeVoskModel(modelPath))
-        return modelPath;
-    await mkdir(modelsRoot, { recursive: true });
-    const zipPath = join(modelsRoot, `${definition.dirName}.zip`);
-    const tempPath = join(modelsRoot, `${definition.dirName}.tmp-${process.pid}-${Date.now()}`);
-    await rm(zipPath, { force: true });
-    await rm(tempPath, { recursive: true, force: true });
-    await downloadFile(definition.url, zipPath);
-    await mkdir(tempPath, { recursive: true });
-    await extractZip(zipPath, tempPath);
-    const extractedPath = join(tempPath, definition.dirName);
-    if (!(await looksLikeVoskModel(extractedPath))) {
-        await rm(tempPath, { recursive: true, force: true });
-        await rm(zipPath, { force: true });
-        throw new Error(`downloaded ${definition.label} (${language}) model did not contain a valid Vosk model`);
-    }
-    await rm(modelPath, { recursive: true, force: true });
-    await rename(extractedPath, modelPath);
-    await rm(tempPath, { recursive: true, force: true });
-    await rm(zipPath, { force: true });
-    return modelPath;
-}
-async function looksLikeVoskModel(modelPath) {
-    return (await pathExists(join(modelPath, "conf", "model.conf"))) && (await pathExists(join(modelPath, "am", "final.mdl")));
+export function buildDeepgramUrl(model, language, rawLinear16) {
+    const url = new URL("wss://api.deepgram.com/v1/listen");
+    url.searchParams.set("model", model.trim() || DEFAULT_DEEPGRAM_MODEL);
+    url.searchParams.set("language", language.trim() || "en");
+    url.searchParams.set("interim_results", "true");
+    url.searchParams.set("punctuate", "true");
+    url.searchParams.set("smart_format", "true");
+    url.searchParams.set("vad_events", "true");
+    url.searchParams.set("endpointing", "300");
+    url.searchParams.set("utterance_end_ms", "1000");
+    if (rawLinear16) {
+        url.searchParams.set("encoding", "linear16");
+        url.searchParams.set("sample_rate", String(SAMPLE_RATE));
+        url.searchParams.set("channels", "1");
+    }
+    return url.toString();
 }
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function downloadFile(url, destination, redirects = 3) {
-    await new Promise((resolve, reject) => {
-        const client = url.startsWith("https:") ? https : http;
-        let settled = false;
-        const finish = (callback) => {
-            if (settled)
-                return;
-            settled = true;
-            callback();
-        };
-        const request = client.get(url, (response) => {
-            const statusCode = response.statusCode ?? 0;
-            const location = response.headers.location;
-            if ([301, 302, 303, 307, 308].includes(statusCode) && location && redirects > 0) {
-                response.resume();
-                const redirectedUrl = new URL(location, url).toString();
-                downloadFile(redirectedUrl, destination, redirects - 1).then(() => finish(resolve), (error) => finish(() => reject(error)));
-                return;
-            }
-            if (statusCode !== 200) {
-                response.resume();
-                finish(() => reject(new Error(`download failed with HTTP ${statusCode}`)));
-                return;
-            }
-            const file = createWriteStream(destination);
-            response.on("error", (error) => {
-                finish(() => reject(error));
-            });
-            pipeline(response, file).then(() => finish(resolve), (error) => finish(() => reject(error)));
-        });
-        request.on("error", (error) => {
-            finish(() => reject(error));
-        });
-    });
-}
-async function extractZip(zipPath, destination) {
-    if (await commandExists("unzip")) {
-        await runCommand("unzip", ["-q", zipPath, "-d", destination]);
-        return;
-    }
-    if (process.platform === "darwin" && await commandExists("ditto")) {
-        await runCommand("ditto", ["-x", "-k", zipPath, destination]);
-        return;
-    }
-    throw new Error("cannot extract Vosk model: install `unzip` (or `ditto` on macOS)");
-}
-async function runCommand(command, args) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"] });
-        let stderr = "";
-        child.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-600);
-        });
-        child.once("error", reject);
-        child.once("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`${command} failed${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
-        });
-    });
-}
-async function loadVoskWithAutoInstall(initialError, progress) {
-    const installOutput = await ensureVoskInstalled(progress, initialError);
-    const attempt = tryLoadVosk();
-    if (attempt.ok)
-        return attempt.module;
-    throw new Error(`automatic Vosk install/build finished, but bindings still cannot load: ${errorMessage(attempt.error)}${installDiagnosticSuffix(installOutput)}`);
-}
-async function ensureVoskInstalled(progress, initialError) {
-    if (voskInstallPromise) {
-        progress("Waiting for Vosk install already in progress...");
-        await voskInstallPromise;
-        return "";
-    }
-    voskInstallPromise = installVoskBindings(progress, initialError).finally(() => {
-        voskInstallPromise = undefined;
-    });
-    return await voskInstallPromise;
-}
-async function installVoskBindings(progress, initialError) {
-    progress(`Installing Vosk bindings (${VOSK_PACKAGE_SPEC})...`);
-    let installOutput = "";
-    try {
-        installOutput = await runNpmCommand(["install", "--no-save", "--package-lock=false", VOSK_PACKAGE_SPEC, "--ignore-scripts"], "Installing Vosk", progress);
-        await patchVoskNativeDependencies(progress);
-        progress("Building Vosk native dependencies...");
-        const rebuildOutput = await runNpmCommand(["rebuild", "ffi-napi", "ref-napi", "--foreground-scripts", "--ignore-scripts=false"], "Building Vosk", progress);
-        const installedAttempt = tryLoadVosk();
-        if (installedAttempt.ok)
-            return `${installOutput}\n${rebuildOutput}`;
-        if (isMissingModuleError(installedAttempt.error)) {
-            throw new Error(`npm install finished without a loadable Vosk package: ${errorMessage(installedAttempt.error)}${installDiagnosticSuffix(`${installOutput}\n${rebuildOutput}`)}`);
-        }
-        progress("Rebuilding Vosk package...");
-        const voskRebuildOutput = await runNpmCommand(["rebuild", "vosk", "--foreground-scripts", "--ignore-scripts=false"], "Building Vosk", progress);
-        return `${installOutput}\n${rebuildOutput}\n${voskRebuildOutput}`;
-    }
-    catch (error) {
-        throw new Error(`automatic Vosk install/build failed: ${errorMessage(error)} (initial load error: ${errorMessage(initialError)})`);
-    }
-}
-async function patchVoskNativeDependencies(progress) {
-    const headerPath = join(projectRoot, "node_modules", "get-uv-event-loop-napi-h", "include", "get-uv-event-loop-napi.h");
-    let source;
+export function parseDeepgramTranscript(data) {
+    const source = typeof data === "string"
+        ? data
+        : Buffer.isBuffer(data)
+            ? data.toString("utf8")
+            : undefined;
+    if (!source)
+        return undefined;
+    let parsed;
     try {
-        source = await readFile(headerPath, "utf8");
+        parsed = JSON.parse(source);
     }
     catch {
-        return;
-    }
-    const oldLine = "napi_get_uv_event_loop__ = &napi_get_uv_event_loop;";
-    const newLine = "napi_get_uv_event_loop__ = (get_uv_event_loop_fn)&napi_get_uv_event_loop;";
-    if (source.includes(newLine))
-        return;
-    if (!source.includes(oldLine))
-        return;
-    await writeFile(headerPath, source.replace(oldLine, newLine));
-    progress("Patched Vosk native headers for Node 24...");
-}
-async function runNpmCommand(args, label, progress) {
-    return await new Promise((resolve, reject) => {
-        const child = spawn(npmCommand(), args, {
-            cwd: projectRoot,
-            env: { ...process.env, npm_config_ignore_scripts: "false" },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let output = "";
-        const observeOutput = (chunk) => {
-            const text = chunk.toString("utf8");
-            output = `${output}${text}`.slice(-1200);
-            const line = lastUsefulLine(text);
-            if (line)
-                progress(`${label}: ${line}`);
-        };
-        child.stdout.on("data", observeOutput);
-        child.stderr.on("data", observeOutput);
-        child.once("error", reject);
-        child.once("close", (code) => {
-            if (code === 0)
-                resolve(output);
-            else
-                reject(new Error(`${npmCommand()} ${args.join(" ")} failed${output.trim() ? `: ${output.trim()}` : ""}`));
-        });
-    });
-}
-function isMissingModuleError(error) {
-    return /Cannot find module ['"]vosk['"]/u.test(errorMessage(error));
-}
-function installDiagnosticSuffix(output) {
-    const summary = compactOutputSummary(output);
-    const nodeHint = nodeVersionCompatibilityHint(output);
-    return `${summary ? ` Last npm output: ${summary}` : ""}${nodeHint ? ` ${nodeHint}` : ""}`;
-}
-function compactOutputSummary(output) {
-    const lines = output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
-    const interesting = lines.filter((line) => /\b(error|ERR!|failed|not ok|incompatible|Cannot find|node-gyp|make:)\b/iu.test(line));
-    const selected = (interesting.length > 0 ? interesting : lines).slice(-8);
-    const summary = selected.join(" | ");
-    return summary.length > 900 ? `${summary.slice(0, 897)}...` : summary;
-}
-function nodeVersionCompatibilityHint(output) {
-    const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "", 10);
-    if (nodeMajor >= 25 && /ffi-napi|node-gyp|napi_add_finalizer|get_uv_event_loop/iu.test(output)) {
-        return `Detected Node ${process.versions.node}; Vosk npm bindings depend on ffi-napi, which may not build on this Node version. Try running Pix with Node 22 or 24.`;
-    }
-    return undefined;
-}
-function lastUsefulLine(text) {
-    const lines = text.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
-    const line = lines.at(-1);
-    if (!line)
         return undefined;
-    return line.length > 96 ? `${line.slice(0, 93)}...` : line;
-}
-function npmCommand() {
-    return process.platform === "win32" ? "npm.cmd" : "npm";
-}
-function tryLoadVosk() {
-    try {
-        return { ok: true, module: loadVosk() };
-    }
-    catch (error) {
-        return { ok: false, error };
-    }
-}
-function loadVosk() {
-    let moduleValue;
-    try {
-        moduleValue = require("vosk");
     }
-    catch (error) {
-        throw new Error(`local Vosk bindings are not ready: ${errorMessage(error)}`);
-    }
-    if (!isVoskModule(moduleValue))
-        throw new Error("installed `vosk` package does not expose Model and Recognizer");
-    return moduleValue;
-}
-function isVoskModule(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const record = value;
-    return typeof record.Model === "function" && typeof record.Recognizer === "function";
+    if (!isRecord(parsed) || parsed.type !== "Results" || !isRecord(parsed.channel))
+        return undefined;
+    const alternatives = parsed.channel.alternatives;
+    if (!Array.isArray(alternatives) || !isRecord(alternatives[0]))
+        return undefined;
+    const transcript = alternatives[0].transcript;
+    if (typeof transcript !== "string")
+        return undefined;
+    const text = normalizeTranscript(transcript);
+    return text ? { text, isFinal: parsed.is_final === true } : undefined;
 }
 async function selectRecorderCommand() {
     const commands = [
@@ -653,25 +513,97 @@ async function selectRecorderCommand() {
     }
     throw new Error("audio recorder not found: install SoX (`rec`/`sox`), ffmpeg, or arecord");
 }
-function transcriptText(result) {
-    const parsed = typeof result === "string" ? parseResultString(result) : result;
-    const text = parsed && typeof parsed.text === "string" ? parsed.text.trim().replace(/\s+/gu, " ") : "";
-    return text || undefined;
+function createDeepgramSocket(url, protocols) {
+    const WebSocketConstructor = globalThis.WebSocket;
+    if (!WebSocketConstructor)
+        throw new Error("this Node runtime does not provide WebSocket support");
+    return new WebSocketConstructor(url, protocols);
+}
+async function waitForSocketOpen(socket) {
+    if (socket.readyState === DEEPGRAM_SOCKET_OPEN)
+        return;
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.removeEventListener("open", onOpen);
+            socket.removeEventListener("error", onError);
+            socket.removeEventListener("close", onClose);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const onOpen = () => finish();
+        const onError = () => finish(new Error("Deepgram WebSocket connection failed"));
+        const onClose = (event) => finish(new Error(`Deepgram WebSocket closed before connecting${event.code ? ` (${event.code}${event.reason ? `: ${event.reason}` : ""})` : ""}`));
+        const timer = setTimeout(() => finish(new Error("Deepgram WebSocket connection timed out")), DEEPGRAM_SOCKET_CONNECT_TIMEOUT_MS);
+        timer.unref?.();
+        socket.addEventListener("open", onOpen);
+        socket.addEventListener("error", onError);
+        socket.addEventListener("close", onClose);
+    });
+}
+function safeCloseSocket(socket) {
+    try {
+        socket.close(1000, "voice input stopped");
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+async function stopRecorderProcess(audioProcess) {
+    if (audioProcess.exitCode !== null)
+        return;
+    const gracefulClose = waitForProcessClose(audioProcess, RECORDER_STOP_GRACE_MS);
+    if (!audioProcess.killed)
+        safeKillProcess(audioProcess, "SIGTERM");
+    if (await gracefulClose)
+        return;
+    if (audioProcess.exitCode === null)
+        safeKillProcess(audioProcess, "SIGKILL");
+    await waitForProcessClose(audioProcess, RECORDER_FORCE_STOP_GRACE_MS);
 }
-function partialTranscriptText(result) {
-    const parsed = typeof result === "string" ? parseResultString(result) : result;
-    const text = parsed && typeof parsed.partial === "string" ? parsed.partial.trim().replace(/\s+/gu, " ") : "";
-    return text || undefined;
+function waitForProcessClose(audioProcess, timeoutMs) {
+    if (audioProcess.exitCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (closed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            audioProcess.removeListener("close", onClose);
+            resolve(closed);
+        };
+        const onClose = () => finish(true);
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref?.();
+        audioProcess.once("close", onClose);
+    });
 }
-function parseResultString(result) {
+function safeKillProcess(audioProcess, signal) {
     try {
-        const parsed = JSON.parse(result);
-        return parsed && typeof parsed === "object" ? parsed : undefined;
+        audioProcess.kill(signal);
     }
     catch {
-        return undefined;
+        // Best-effort cleanup; shutdown has its own outer deadline.
     }
 }
+function normalizeTranscript(text) {
+    const normalized = text.trim().replace(/\s+/gu, " ");
+    return normalized || undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }