@qvac/sdk 0.14.1 → 0.16.0

package/dist/examples/transcription/parakeet-tdt-filesystem-chunked.js

@@ -0,0 +1,203 @@
+/**
+ * Parakeet TDT transcription for long audio files.
+ *
+ * Usage:
+ *   bun run examples/transcription/parakeet-tdt-filesystem-chunked.ts <audio-file> [parakeet-tdt-gguf]
+ *
+ * FFmpeg first detects silence, then this example selects boundaries near
+ * 45 seconds and transcribes one segment at a time. Segments never exceed
+ * 60 seconds, which keeps audio and inference memory bounded. Any audio
+ * format supported by FFmpeg can be used.
+ */
+import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0 } from '@qvac/sdk';
+import { spawn } from 'child_process';
+const SAMPLE_RATE = 16000;
+const SILENCE_NOISE_DB = -35;
+const SILENCE_DURATION_S = 0.5;
+const MIN_SEGMENT_S = 10;
+const TARGET_SEGMENT_S = 45;
+const MAX_SEGMENT_S = 60;
+function runCommand(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.stderr.on('data', (chunk) => stderr.push(chunk));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const stderrText = Buffer.concat(stderr).toString();
+            if (code !== 0) {
+                reject(new Error(`${command} exited with code ${code}: ${stderrText.trim()}`));
+                return;
+            }
+            resolve({ stdout: Buffer.concat(stdout), stderr: stderrText });
+        });
+    });
+}
+async function getAudioDuration(audioPath) {
+    const result = await runCommand('ffprobe', [
+        '-v',
+        'error',
+        '-show_entries',
+        'format=duration',
+        '-of',
+        'default=noprint_wrappers=1:nokey=1',
+        audioPath
+    ]);
+    const duration = Number.parseFloat(result.stdout.toString().trim());
+    if (!Number.isFinite(duration) || duration <= 0) {
+        throw new Error(`Could not determine audio duration for ${audioPath}`);
+    }
+    return duration;
+}
+async function detectSilences(audioPath, duration) {
+    const result = await runCommand('ffmpeg', [
+        '-hide_banner',
+        '-nostats',
+        '-i',
+        audioPath,
+        '-vn',
+        '-af',
+        `silencedetect=noise=${SILENCE_NOISE_DB}dB:d=${SILENCE_DURATION_S}`,
+        '-f',
+        'null',
+        '-'
+    ]);
+    const intervals = [];
+    let currentStart = null;
+    for (const line of result.stderr.split('\n')) {
+        const startMatch = line.match(/silence_start:\s*([0-9.]+)/);
+        if (startMatch?.[1]) {
+            const start = Number.parseFloat(startMatch[1]);
+            if (Number.isFinite(start))
+                currentStart = start;
+        }
+        const endMatch = line.match(/silence_end:\s*([0-9.]+)/);
+        if (endMatch?.[1] && currentStart !== null) {
+            const end = Number.parseFloat(endMatch[1]);
+            if (Number.isFinite(end) && end > currentStart) {
+                intervals.push({ start: currentStart, end });
+            }
+            currentStart = null;
+        }
+    }
+    if (currentStart !== null && currentStart < duration) {
+        intervals.push({ start: currentStart, end: duration });
+    }
+    return intervals;
+}
+function createAudioSegments(duration, silences) {
+    const silenceMidpoints = silences.map(({ start, end }) => start + (end - start) / 2);
+    const segments = [];
+    let start = 0;
+    while (duration - start > MAX_SEGMENT_S) {
+        const target = start + TARGET_SEGMENT_S;
+        const minimumCut = start + MIN_SEGMENT_S;
+        const maximumCut = start + MAX_SEGMENT_S;
+        const candidates = silenceMidpoints.filter((candidate) => candidate >= minimumCut && candidate <= maximumCut);
+        const firstCandidate = candidates[0];
+        const cut = firstCandidate === undefined
+            ? Math.min(target, duration - MIN_SEGMENT_S)
+            : candidates.slice(1).reduce((best, candidate) => {
+                return Math.abs(candidate - target) < Math.abs(best - target) ? candidate : best;
+            }, firstCandidate);
+        segments.push({ start, end: cut });
+        start = cut;
+    }
+    if (duration > start) {
+        segments.push({ start, end: duration });
+    }
+    return segments;
+}
+async function decodeSegment(audioPath, segment) {
+    const result = await runCommand('ffmpeg', [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        '-ss',
+        segment.start.toFixed(3),
+        '-i',
+        audioPath,
+        '-t',
+        (segment.end - segment.start).toFixed(3),
+        '-vn',
+        '-ar',
+        String(SAMPLE_RATE),
+        '-ac',
+        '1',
+        '-sample_fmt',
+        's16',
+        '-f',
+        's16le',
+        'pipe:1'
+    ]);
+    return result.stdout;
+}
+function formatTimestamp(seconds) {
+    const totalTenths = Math.round(seconds * 10);
+    const hours = Math.floor(totalTenths / 36000);
+    const minutes = Math.floor((totalTenths % 36000) / 600);
+    const remainingSeconds = ((totalTenths % 600) / 10).toFixed(1).padStart(4, '0');
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${remainingSeconds}`;
+}
+const args = process.argv.slice(2);
+if (!args[0]) {
+    console.error('Usage: bun run examples/transcription/parakeet-tdt-filesystem-chunked.ts ' +
+        '<audio-file> [parakeet-tdt-gguf]');
+    process.exit(1);
+}
+const audioFilePath = args[0];
+const parakeetModelSrc = args[1] ?? PARAKEET_TDT_0_6B_V3_Q8_0;
+let modelId = null;
+try {
+    await runCommand('ffmpeg', ['-version']);
+    await runCommand('ffprobe', ['-version']);
+    console.log('▸ Detecting silence and planning bounded segments...');
+    const duration = await getAudioDuration(audioFilePath);
+    const silences = await detectSilences(audioFilePath, duration);
+    const segments = createAudioSegments(duration, silences);
+    console.log(`▸ Audio duration: ${formatTimestamp(duration)}; detected ${silences.length} silence interval(s); planned ${segments.length} segment(s)`);
+    console.log('▸ Loading Parakeet TDT model...');
+    modelId = await loadModel({
+        modelSrc: parakeetModelSrc,
+        modelType: 'parakeet-transcription',
+        onProgress: (p) => {
+            const mb = (n) => (n / 1e6).toFixed(1);
+            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (p.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    const transcript = [];
+    for (const [index, segment] of segments.entries()) {
+        console.log(`▸ Segment ${index + 1}/${segments.length}: ${formatTimestamp(segment.start)} - ${formatTimestamp(segment.end)}`);
+        const audioChunk = await decodeSegment(audioFilePath, segment);
+        const text = await transcribe({ modelId, audioChunk });
+        const normalizedText = text.trim();
+        if (normalizedText && !normalizedText.includes('[No speech detected]')) {
+            transcript.push(normalizedText);
+            console.log(normalizedText);
+        }
+    }
+    console.log('\n▸ Complete transcript');
+    console.log(transcript.join(' '));
+    await unloadModel({ modelId });
+    modelId = null;
+    console.log('▸ Done');
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    if (modelId) {
+        try {
+            await unloadModel({ modelId });
+        }
+        catch (unloadError) {
+            console.error('✖ Failed to unload model:', unloadError);
+        }
+    }
+    process.exit(1);
+}

package/dist/examples/transcription/parakeet-tdt-filesystem.js

@@ -10,39 +10,39 @@
  *
  * Audio should be 16 kHz mono PCM in a WAV container.
  */
-import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0, } from "@qvac/sdk";
+import { loadModel, unloadModel, transcribe, PARAKEET_TDT_0_6B_V3_Q8_0 } from '@qvac/sdk';
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error("Usage: bun run examples/transcription/parakeet-tdt-filesystem.ts <wav-file-path> " +
-        "[parakeet-tdt-gguf]");
-    console.error("\nIf the model path is omitted, defaults to the registry model.");
+    console.error('Usage: bun run examples/transcription/parakeet-tdt-filesystem.ts <wav-file-path> ' +
+        '[parakeet-tdt-gguf]');
+    console.error('\nIf the model path is omitted, defaults to the registry model.');
     process.exit(1);
 }
 const audioFilePath = args[0];
 const parakeetModelSrc = args[1] ?? PARAKEET_TDT_0_6B_V3_Q8_0;
 try {
-    console.log("▸ Starting Parakeet transcription example...");
-    console.log("▸ Loading Parakeet model...");
+    console.log('▸ Starting Parakeet transcription example...');
+    console.log('▸ Loading Parakeet model...');
     const modelId = await loadModel({
         modelSrc: parakeetModelSrc,
-        modelType: "parakeet-transcription",
+        modelType: 'parakeet-transcription',
         onProgress: (p) => {
             const mb = (n) => (n / 1e6).toFixed(1);
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Parakeet model loaded with ID: ${modelId}`);
-    console.log("▸ Transcribing audio...");
+    console.log('▸ Transcribing audio...');
     const text = await transcribe({ modelId, audioChunk: audioFilePath });
     console.log(text);
-    console.log("▸ Unloading Parakeet model...");
+    console.log('▸ Unloading Parakeet model...');
     await unloadModel({ modelId });
-    console.log("▸ Parakeet model unloaded successfully");
+    console.log('▸ Parakeet model unloaded successfully');
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/transcription/whispercpp-filesystem-streaming.js

@@ -12,29 +12,29 @@
  * Set SAMPLE_FILE to a custom WAV, or download the default audio into examples/audio/:
  *   https://github.com/tetherto/qvac/blob/main/packages/sdk/examples/audio/diarization-sample-16k.wav
  */
-import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2, } from "@qvac/sdk";
-import { spawn } from "child_process";
-import path from "path";
-import { fileURLToPath } from "url";
+import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2 } from '@qvac/sdk';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const SAMPLE_FILE = path.resolve(__dirname, "../audio/diarization-sample-16k.wav");
+const SAMPLE_FILE = path.resolve(__dirname, '../audio/diarization-sample-16k.wav');
 const SAMPLE_RATE = 16000;
 const BYTES_PER_SAMPLE = 4; // f32le
 const CHUNK_SIZE = Math.floor(0.1 * SAMPLE_RATE) * BYTES_PER_SAMPLE; // 100ms chunks
 try {
-    console.log("▸ transcribeStream file test");
+    console.log('▸ transcribeStream file test');
     console.log(`▸ File: ${SAMPLE_FILE}`);
     console.log(`▸ Chunk size: ${CHUNK_SIZE} bytes (100ms)`);
-    console.log("▸ Loading model...");
+    console.log('▸ Loading model...');
     const modelId = await loadModel({
         modelSrc: WHISPER_TINY,
         modelConfig: {
             vadModelSrc: VAD_SILERO_5_1_2,
-            audio_format: "f32le",
-            strategy: "greedy",
+            audio_format: 'f32le',
+            strategy: 'greedy',
             n_threads: 4,
-            language: "en",
+            language: 'en',
             no_timestamps: true,
             suppress_blank: true,
             suppress_nst: true,
@@ -44,39 +44,39 @@ try {
                 min_speech_duration_ms: 250,
                 min_silence_duration_ms: 500,
                 max_speech_duration_s: 15.0,
-                speech_pad_ms: 200,
-            },
-        },
+                speech_pad_ms: 200
+            }
+        }
     });
     console.log(`▸ Model loaded: ${modelId}`);
-    console.log("▸ Opening live session...");
+    console.log('▸ Opening live session...');
     const session = await transcribeStream({ modelId, metadata: true });
-    console.log("▸ Session open. Streaming audio...");
-    const ffmpeg = spawn("ffmpeg", [
-        "-i",
+    console.log('▸ Session open. Streaming audio...');
+    const ffmpeg = spawn('ffmpeg', [
+        '-i',
         SAMPLE_FILE,
-        "-ar",
+        '-ar',
         String(SAMPLE_RATE),
-        "-ac",
-        "1",
-        "-sample_fmt",
-        "flt",
-        "-f",
-        "f32le",
-        "pipe:1",
-    ], { stdio: ["ignore", "pipe", "ignore"] });
+        '-ac',
+        '1',
+        '-sample_fmt',
+        'flt',
+        '-f',
+        'f32le',
+        'pipe:1'
+    ], { stdio: ['ignore', 'pipe', 'ignore'] });
     let totalBytes = 0;
-    ffmpeg.stdout.on("data", (raw) => {
+    ffmpeg.stdout.on('data', (raw) => {
         for (let offset = 0; offset < raw.length; offset += CHUNK_SIZE) {
             const chunk = raw.subarray(offset, offset + CHUNK_SIZE);
             session.write(chunk);
             totalBytes += chunk.length;
         }
     });
-    ffmpeg.on("close", () => {
+    ffmpeg.on('close', () => {
         const durationSec = totalBytes / (SAMPLE_RATE * BYTES_PER_SAMPLE);
         console.log(`▸ Audio streamed: ${totalBytes} bytes (~${durationSec.toFixed(1)}s)`);
-        console.log("▸ Waiting for transcription...");
+        console.log('▸ Waiting for transcription...');
         session.end();
     });
     const segments = [];
@@ -88,17 +88,17 @@ try {
     }
     console.log(`\n▸ Segments: ${segments.length}`);
     if (segments.length > 0) {
-        console.log(segments.map((s) => s.text.trim()).join(" "));
+        console.log(segments.map((s) => s.text.trim()).join(' '));
     }
     else {
-        console.log("▸ No transcription segments received!");
+        console.log('▸ No transcription segments received!');
     }
-    console.log("▸ Unloading model...");
+    console.log('▸ Unloading model...');
     await unloadModel({ modelId });
-    console.log("▸ Done.");
+    console.log('▸ Done.');
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/transcription/whispercpp-filesystem.js

@@ -1,24 +1,24 @@
-import { loadModel, unloadModel, transcribe, WHISPER_TINY } from "@qvac/sdk";
+import { loadModel, unloadModel, transcribe, WHISPER_TINY } from '@qvac/sdk';
 // Parse command line arguments
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error("Usage: bun run examples/whispercpp-filesystem.ts <wav-file-path>");
+    console.error('Usage: bun run examples/whispercpp-filesystem.ts <wav-file-path>');
     process.exit(1);
 }
 const audioFilePath = args[0];
 try {
-    console.log("▸ Starting Whisper transcription example...");
+    console.log('▸ Starting Whisper transcription example...');
     // Load the Whisper model
-    console.log("▸ Loading Whisper model...");
+    console.log('▸ Loading Whisper model...');
     const modelId = await loadModel({
         modelSrc: WHISPER_TINY,
         modelConfig: {
-            audio_format: "f32le",
+            audio_format: 'f32le',
             // Sampling strategy
-            strategy: "greedy",
+            strategy: 'greedy',
             n_threads: 4,
             // Transcription options
-            language: "en",
+            language: 'en',
             translate: false,
             no_timestamps: false,
             single_segment: false,
@@ -38,32 +38,32 @@ try {
                 min_silence_duration_ms: 150,
                 max_speech_duration_s: 30.0,
                 speech_pad_ms: 600,
-                samples_overlap: 0.3,
+                samples_overlap: 0.3
             },
             // Context parameters for GPU
             contextParams: {
                 use_gpu: true,
                 flash_attn: true,
-                gpu_device: 0,
-            },
+                gpu_device: 0
+            }
         },
         onProgress: (p) => {
             const mb = (n) => (n / 1e6).toFixed(1);
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Whisper model loaded with ID: ${modelId}`);
     // Perform transcription with per-segment metadata
-    console.log("▸ Transcribing audio...");
+    console.log('▸ Transcribing audio...');
     const segments = await transcribe({
         modelId,
         audioChunk: audioFilePath,
-        metadata: true,
+        metadata: true
     });
-    console.log("▸ Transcription result:");
+    console.log('▸ Transcription result:');
     for (const segment of segments) {
         const start = (segment.startMs / 1000).toFixed(2);
         const end = (segment.endMs / 1000).toFixed(2);
@@ -71,14 +71,14 @@ try {
     }
     console.log(`\nFull transcript: ${segments
         .map((s) => s.text)
-        .join("")
+        .join('')
         .trim()}`);
     // Unload the model when done
-    console.log("▸ Unloading Whisper model...");
+    console.log('▸ Unloading Whisper model...');
     await unloadModel({ modelId });
-    console.log("▸ Whisper model unloaded successfully");
+    console.log('▸ Whisper model unloaded successfully');
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/transcription/whispercpp-microphone-conversation.js

@@ -16,44 +16,44 @@
  *
  * Requirements: FFmpeg installed, microphone access.
  */
-import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2, } from "@qvac/sdk";
-import { spawnSync } from "child_process";
-import { startMicrophone } from "../audio/mic-input";
+import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2 } from '@qvac/sdk';
+import { spawnSync } from 'child_process';
+import { startMicrophone } from '../audio/mic-input';
 const SAMPLE_RATE = 16000;
 try {
-    const r = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    const r = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
     if (r.error || r.status !== 0)
-        throw new Error("FFmpeg not found");
+        throw new Error('FFmpeg not found');
 }
 catch {
-    console.error("✖ FFmpeg is required. Install it and try again.");
+    console.error('✖ FFmpeg is required. Install it and try again.');
     process.exit(1);
 }
 let modelId = null;
 let ffmpeg = null;
 async function cleanup() {
-    console.log("\n\n▸ Stopping...");
+    console.log('\n\n▸ Stopping...');
     ffmpeg?.kill();
     if (modelId)
         await unloadModel({ modelId });
-    console.log("▸ Done.");
+    console.log('▸ Done.');
 }
-process.on("SIGINT", () => {
+process.on('SIGINT', () => {
     void cleanup().finally(() => process.exit(0));
 });
-process.on("SIGTERM", () => {
+process.on('SIGTERM', () => {
     void cleanup().finally(() => process.exit(0));
 });
 try {
-    console.log("▸ Loading model (whisper-tiny + Silero VAD)...");
+    console.log('▸ Loading model (whisper-tiny + Silero VAD)...');
     modelId = await loadModel({
         modelSrc: WHISPER_TINY,
         modelConfig: {
             vadModelSrc: VAD_SILERO_5_1_2,
-            audio_format: "f32le",
-            strategy: "greedy",
+            audio_format: 'f32le',
+            strategy: 'greedy',
             n_threads: 4,
-            language: "en",
+            language: 'en',
             no_timestamps: true,
             suppress_blank: true,
             suppress_nst: true,
@@ -63,33 +63,33 @@ try {
                 min_speech_duration_ms: 250,
                 min_silence_duration_ms: 300,
                 max_speech_duration_s: 15.0,
-                speech_pad_ms: 100,
-            },
-        },
+                speech_pad_ms: 100
+            }
+        }
     });
-    console.log("▸ Model loaded.\n");
-    ffmpeg = startMicrophone({ sampleRate: SAMPLE_RATE, format: "f32le" });
+    console.log('▸ Model loaded.\n');
+    ffmpeg = startMicrophone({ sampleRate: SAMPLE_RATE, format: 'f32le' });
     const session = await transcribeStream({
         modelId,
         emitVadEvents: true,
-        endOfTurnSilenceMs: 800,
+        endOfTurnSilenceMs: 800
     });
-    ffmpeg.stdout.on("data", (chunk) => session.write(chunk));
-    console.log("▸ Listening... speak and pause to see transcripts, VAD events, and end-of-turn signals.\n");
+    ffmpeg.stdout.on('data', (chunk) => session.write(chunk));
+    console.log('▸ Listening... speak and pause to see transcripts, VAD events, and end-of-turn signals.\n');
     let lastSpeaking = false;
     for await (const event of session) {
         switch (event.type) {
-            case "text":
+            case 'text':
                 console.log(`> ${event.text.trim()}`);
                 break;
-            case "vad":
+            case 'vad':
                 if (event.speaking !== lastSpeaking) {
                     console.log(`▸ [vad] speaking=${event.speaking} probability=${event.probability.toFixed(2)}`);
                     lastSpeaking = event.speaking;
                 }
                 break;
-            case "endOfTurn":
-                if (event.source === "whisper") {
+            case 'endOfTurn':
+                if (event.source === 'whisper') {
                     console.log(`▸ [endOfTurn] silence ${event.silenceDurationMs}ms — turn complete\n`);
                 }
                 else {
@@ -100,7 +100,7 @@ try {
     }
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     await cleanup();
     process.exit(1);
 }

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

@@ -8,29 +8,29 @@
  *
  * Requirements: FFmpeg installed, microphone access.
  */
-import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2, } from "@qvac/sdk";
-import { spawnSync } from "child_process";
-import { startMicrophone } from "../audio/mic-input";
+import { loadModel, unloadModel, transcribeStream, WHISPER_TINY, VAD_SILERO_5_1_2 } from '@qvac/sdk';
+import { spawnSync } from 'child_process';
+import { startMicrophone } from '../audio/mic-input';
 const SAMPLE_RATE = 16000;
 // ── Main ──
 try {
-    const r = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    const r = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
     if (r.error || r.status !== 0)
-        throw new Error("FFmpeg not found");
+        throw new Error('FFmpeg not found');
 }
 catch {
-    console.error("✖ FFmpeg is required. Install it and try again.");
+    console.error('✖ FFmpeg is required. Install it and try again.');
     process.exit(1);
 }
-console.log("▸ Loading model (whisper-tiny + Silero VAD)...");
+console.log('▸ Loading model (whisper-tiny + Silero VAD)...');
 const modelId = await loadModel({
     modelSrc: WHISPER_TINY,
     modelConfig: {
         vadModelSrc: VAD_SILERO_5_1_2,
-        audio_format: "f32le",
-        strategy: "greedy",
+        audio_format: 'f32le',
+        strategy: 'greedy',
         n_threads: 4,
-        language: "en",
+        language: 'en',
         no_timestamps: true,
         suppress_blank: true,
         suppress_nst: true,
@@ -40,26 +40,26 @@ const modelId = await loadModel({
             min_speech_duration_ms: 250,
             min_silence_duration_ms: 300,
             max_speech_duration_s: 15.0,
-            speech_pad_ms: 100,
-        },
-    },
+            speech_pad_ms: 100
+        }
+    }
 });
-console.log("▸ Model loaded.\n");
+console.log('▸ Model loaded.\n');
 const ffmpeg = startMicrophone({
     sampleRate: SAMPLE_RATE,
-    format: "f32le",
+    format: 'f32le'
 });
 const session = await transcribeStream({ modelId });
-ffmpeg.stdout.on("data", (chunk) => session.write(chunk));
-console.log("▸ Listening... speak and pause to see transcriptions.\n");
+ffmpeg.stdout.on('data', (chunk) => session.write(chunk));
+console.log('▸ Listening... speak and pause to see transcriptions.\n');
 for await (const text of session) {
     console.log(`> ${text.trim()}`);
 }
 async function cleanup() {
-    console.log("\n\n▸ Stopping...");
+    console.log('\n\n▸ Stopping...');
     ffmpeg.kill();
     await unloadModel({ modelId });
-    console.log("▸ Done.");
+    console.log('▸ Done.');
 }
-process.on("SIGINT", () => void cleanup());
-process.on("SIGTERM", () => void cleanup());
+process.on('SIGINT', () => void cleanup());
+process.on('SIGTERM', () => void cleanup());