Upload 7 files

audio_processor.js

@@ -0,0 +1,36 @@
+/**
+ * AudioWorklet Processor for low-latency audio capture
+ * Runs in a separate audio thread for minimal latency
+ */
+
+class AudioProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super();
+        this.bufferSize = 512;  // Send audio every ~32ms at 16kHz
+        this.buffer = [];
+    }
+
+    process(inputs, outputs, parameters) {
+        const input = inputs[0];
+        if (input.length > 0) {
+            const channelData = input[0];
+
+            // Accumulate samples
+            for (let i = 0; i < channelData.length; i++) {
+                this.buffer.push(channelData[i]);
+            }
+
+            // Send when we have enough
+            while (this.buffer.length >= this.bufferSize) {
+                const chunk = this.buffer.splice(0, this.bufferSize);
+                this.port.postMessage({
+                    audio: new Float32Array(chunk)
+                });
+            }
+        }
+
+        return true;  // Keep processor alive
+    }
+}
+
+registerProcessor('audio-processor', AudioProcessor);

encoder_sleeker_fp32.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3639b95297009937838ae8fa9193602c7407e60a687b1591ffd2cc4b616d87d0
+size 31139657

encoder_worker.js

@@ -0,0 +1,214 @@
+/**
+ * Encoder Worker - Runs preprocessor + encoder in a separate thread
+ */
+
+importScripts('https://cdn.jsdelivr.net/npm/[email protected]/dist/ort.min.js');
+
+// Configure ONNX Runtime to find WASM files from CDN
+ort.env.wasm.wasmPaths = 'https://cdn.jsdelivr.net/npm/[email protected]/dist/';
+
+// Model config
+let cfg = null;
+let preprocessor = null;
+let encoder = null;
+let tailLatency = 0;
+
+// Preprocessor state
+let prepSession = null;
+let prepDim = 0;
+let prepC1 = 0;
+let prepStateC1 = null;
+let prepStateC2 = null;
+
+// Encoder state
+let encSession = null;
+let encDim = 0;
+let encNPast = 0;
+let encNFuture = 0;
+let encEncoderDepth = 0;
+let encContextSize = 0;
+let encInputBuffer = [];
+let encTotalInputFrames = 0;
+let encTotalOutputFrames = 0;
+
+function resetPreprocessor() {
+    if (prepStateC1) prepStateC1.fill(0);
+    if (prepStateC2) prepStateC2.fill(0);
+}
+
+function resetEncoder() {
+    encInputBuffer = [];
+    encTotalInputFrames = 0;
+    encTotalOutputFrames = 0;
+}
+
+async function processPreprocessor(audioChunk) {
+    const feeds = {
+        'audio_chunk': new ort.Tensor('float32', audioChunk, [1, audioChunk.length]),
+        'state_c1': new ort.Tensor('float32', prepStateC1, [1, 4, prepDim]),
+        'state_c2': new ort.Tensor('float32', prepStateC2, [1, 4, prepC1])
+    };
+
+    const results = await prepSession.run(feeds);
+
+    // Update states
+    prepStateC1.set(results.new_state_c1.data);
+    prepStateC2.set(results.new_state_c2.data);
+
+    return {
+        data: results.features.data,
+        dims: results.features.dims
+    };
+}
+
+async function processEncoder(melData, melDims, flush = true) {
+    const newFrames = melDims[1];
+
+    // Append new frames to buffer
+    for (let f = 0; f < newFrames; f++) {
+        const frame = new Float32Array(encDim);
+        for (let d = 0; d < encDim; d++) {
+            frame[d] = melData[f * encDim + d];
+        }
+        encInputBuffer.push(frame);
+    }
+
+    encTotalInputFrames += newFrames;
+
+    // Calculate output range
+    const canOutput = flush
+        ? encTotalInputFrames
+        : Math.max(0, encTotalInputFrames - tailLatency);
+
+    const outputFrom = flush
+        ? Math.max(0, encTotalOutputFrames - tailLatency)
+        : encTotalOutputFrames;
+
+    const newOutputCount = canOutput - outputFrom;
+
+    if (newOutputCount <= 0) {
+        return { data: new Float32Array(0), dims: [1, 0, encDim] };
+    }
+
+    // Prepare input buffer tensor
+    const bufferFrames = encInputBuffer.length;
+    const bufferData = new Float32Array(bufferFrames * encDim);
+    for (let f = 0; f < bufferFrames; f++) {
+        bufferData.set(encInputBuffer[f], f * encDim);
+    }
+
+    const feeds = {
+        'input': new ort.Tensor('float32', bufferData, [1, bufferFrames, encDim])
+    };
+
+    const results = await encSession.run(feeds);
+    const fullOutput = results.output;
+
+    // Calculate which frames to return
+    const bufStartFrame = encTotalInputFrames - bufferFrames;
+    const outputStart = outputFrom - bufStartFrame;
+
+    // Extract the subset of output
+    const resultData = new Float32Array(newOutputCount * encDim);
+    for (let f = 0; f < newOutputCount; f++) {
+        for (let d = 0; d < encDim; d++) {
+            resultData[f * encDim + d] = fullOutput.data[(outputStart + f) * encDim + d];
+        }
+    }
+
+    // Trim input buffer to context size
+    if (encInputBuffer.length > encContextSize) {
+        encInputBuffer = encInputBuffer.slice(-encContextSize);
+    }
+
+    encTotalOutputFrames = canOutput;
+    return { data: resultData, dims: [1, newOutputCount, encDim] };
+}
+
+self.onmessage = async function(e) {
+    const { type, data } = e.data;
+
+    switch (type) {
+        case 'init': {
+            try {
+                cfg = data.cfg;
+                const onnxUrl = data.onnxUrl;
+                const modelName = data.modelName;
+                const dtype = 'fp32';
+
+                tailLatency = cfg.n_future * cfg.encoder_depth;
+
+                // Initialize preprocessor
+                self.postMessage({ type: 'status', message: 'Loading preprocessor...' });
+                prepSession = await ort.InferenceSession.create(
+                    `${onnxUrl}/preprocessor_streaming_${modelName}_${dtype}.onnx`
+                );
+                prepDim = cfg.dim;
+                prepC1 = 2 * cfg.dim;
+                prepStateC1 = new Float32Array(4 * cfg.dim);
+                prepStateC2 = new Float32Array(4 * prepC1);
+
+                // Initialize encoder
+                self.postMessage({ type: 'status', message: 'Loading encoder...' });
+                encSession = await ort.InferenceSession.create(
+                    `${onnxUrl}/encoder_${modelName}_${dtype}.onnx`
+                );
+                encDim = cfg.dim;
+                encNPast = cfg.n_past;
+                encNFuture = cfg.n_future;
+                encEncoderDepth = cfg.encoder_depth;
+                encContextSize = cfg.encoder_depth * (cfg.n_past + cfg.n_future);
+
+                self.postMessage({ type: 'ready' });
+            } catch (err) {
+                self.postMessage({ type: 'error', message: err.message });
+            }
+            break;
+        }
+
+        case 'segment_start': {
+            resetPreprocessor();
+            resetEncoder();
+            self.postMessage({
+                type: 'segment_start',
+                segmentId: data.segmentId
+            });
+            break;
+        }
+
+        case 'segment_end': {
+            self.postMessage({
+                type: 'segment_end',
+                segmentId: data.segmentId
+            });
+            break;
+        }
+
+        case 'audio': {
+            try {
+                // Process through preprocessor
+                const mel = await processPreprocessor(new Float32Array(data.audio));
+
+                const audioMs = (data.audio.length / 16000 * 1000).toFixed(0);
+                console.log(`Audio ${data.audio.length} samples (${audioMs}ms) → Mel ${mel.dims[1]} frames`);
+
+                // Process through encoder with flush=true
+                const enc = await processEncoder(mel.data, mel.dims, true);
+
+                console.log(`Mel ${mel.dims[1]} frames → Encoder ${enc.dims[1]} frames (accumulated: ${encTotalOutputFrames})`);
+
+                if (enc.dims[1] > 0) {
+                    self.postMessage({
+                        type: 'features',
+                        segmentId: data.segmentId,
+                        features: enc.data,
+                        dims: enc.dims
+                    }, [enc.data.buffer]);  // Transfer ownership
+                }
+            } catch (err) {
+                console.error('Encoder error:', err);
+            }
+            break;
+        }
+    }
+};

index.html

@@ -1,19 +1,427 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Streaming ASR Demo - Moonshine</title>
+    <style>
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: #1a1a2e;
+            color: #eee;
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 900px;
+            margin: 0 auto;
+        }
+
+        h1 {
+            text-align: center;
+            margin-bottom: 20px;
+            color: #00d4ff;
+        }
+
+        .status-bar {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background: #16213e;
+            padding: 15px 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+
+        .status-indicator {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .status-dot {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+            background: #666;
+        }
+
+        .status-dot.idle { background: #666; }
+        .status-dot.listening { background: #00ff88; animation: pulse 1s infinite; }
+        .status-dot.recording { background: #ff4444; animation: pulse 0.5s infinite; }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+
+        .controls {
+            display: flex;
+            gap: 10px;
+        }
+
+        button {
+            padding: 10px 20px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: all 0.2s;
+        }
+
+        button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .btn-primary {
+            background: #00d4ff;
+            color: #1a1a2e;
+        }
+
+        .btn-primary:hover:not(:disabled) {
+            background: #00a8cc;
+        }
+
+        .btn-danger {
+            background: #ff4444;
+            color: white;
+        }
+
+        .btn-danger:hover:not(:disabled) {
+            background: #cc3333;
+        }
+
+        .vad-section {
+            background: #16213e;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+
+        .vad-section h3 {
+            margin-bottom: 15px;
+            color: #00d4ff;
+        }
+
+        .vad-graph {
+            background: #0f0f23;
+            border-radius: 5px;
+            padding: 10px;
+            height: 120px;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .vad-canvas {
+            width: 100%;
+            height: 100%;
+        }
+
+        .vad-bar {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            margin-top: 15px;
+        }
+
+        .vad-bar-container {
+            flex: 1;
+            height: 20px;
+            background: #0f0f23;
+            border-radius: 10px;
+            overflow: hidden;
+        }
+
+        .vad-bar-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #00ff88, #00d4ff);
+            width: 0%;
+            transition: width 0.1s;
+        }
+
+        .vad-value {
+            min-width: 50px;
+            text-align: right;
+            font-family: monospace;
+        }
+
+        .pipeline-status {
+            display: flex;
+            gap: 15px;
+            margin-top: 15px;
+            font-family: monospace;
+            font-size: 12px;
+            color: #888;
+        }
+
+        .transcripts-section {
+            background: #16213e;
+            padding: 20px;
+            border-radius: 10px;
+            min-height: 300px;
+        }
+
+        .transcripts-section h3 {
+            margin-bottom: 15px;
+            color: #00d4ff;
+        }
+
+        .transcripts-list {
+            max-height: 200px;
+            overflow-y: auto;
+        }
+
+        .transcript-item {
+            padding: 10px 15px;
+            background: #0f0f23;
+            border-radius: 5px;
+            margin-bottom: 10px;
+            display: flex;
+            gap: 10px;
+        }
+
+        .transcript-duration {
+            color: #00d4ff;
+            font-family: monospace;
+            min-width: 50px;
+        }
+
+        .transcript-text {
+            flex: 1;
+        }
+
+        .live-caption {
+            padding: 30px 40px;
+            background: rgba(0, 0, 0, 0.75);
+            border-radius: 12px;
+            margin-top: 25px;
+            min-height: 100px;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            text-align: center;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+            transition: all 0.3s ease;
+        }
+
+        .live-caption.active {
+            background: rgba(0, 0, 0, 0.85);
+            border-color: rgba(255, 68, 68, 0.3);
+            box-shadow: 0 8px 32px rgba(255, 68, 68, 0.15);
+        }
+
+        .live-caption-label {
+            font-size: 11px;
+            color: rgba(255, 255, 255, 0.5);
+            text-transform: uppercase;
+            letter-spacing: 2px;
+            margin-bottom: 12px;
+        }
+
+        .live-caption.active .live-caption-label {
+            color: #ff6b6b;
+        }
+
+        .live-caption-text {
+            font-size: 28px;
+            font-weight: 400;
+            line-height: 1.5;
+            min-height: 40px;
+            color: #ffffff;
+            text-shadow: 0 2px 4px rgba(0, 0, 0, 0.5);
+            max-width: 100%;
+            word-wrap: break-word;
+        }
+
+        .live-caption-text.placeholder {
+            color: rgba(255, 255, 255, 0.35);
+            font-style: italic;
+            font-size: 20px;
+            font-weight: 300;
+        }
+
+        .config-section {
+            background: #16213e;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+
+        .config-section h3 {
+            margin-bottom: 15px;
+            color: #00d4ff;
+        }
+
+        .config-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+        }
+
+        .config-item {
+            display: flex;
+            flex-direction: column;
+            gap: 5px;
+        }
+
+        .config-item label {
+            font-size: 12px;
+            color: #888;
+        }
+
+        .config-item select, .config-item input {
+            padding: 8px;
+            border: 1px solid #333;
+            border-radius: 5px;
+            background: #0f0f23;
+            color: #eee;
+        }
+
+        .loading-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.8);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 1000;
+        }
+
+        .loading-overlay.hidden {
+            display: none;
+        }
+
+        .loading-content {
+            text-align: center;
+        }
+
+        .loading-spinner {
+            width: 50px;
+            height: 50px;
+            border: 3px solid #333;
+            border-top-color: #00d4ff;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 20px;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        .loading-text {
+            color: #00d4ff;
+        }
+
+        .error-message {
+            background: #ff4444;
+            color: white;
+            padding: 15px;
+            border-radius: 5px;
+            margin-bottom: 20px;
+            display: none;
+        }
+
+        .error-message.visible {
+            display: block;
+        }
+    </style>
+</head>
+<body>
+    <div class="loading-overlay hidden" id="loadingOverlay">
+        <div class="loading-content">
+            <div class="loading-spinner"></div>
+            <div class="loading-text" id="loadingText">Loading models...</div>
+        </div>
+    </div>
+
+    <div class="container">
+        <h1>Streaming ASR Demo</h1>
+
+        <div class="error-message" id="errorMessage"></div>
+
+        <div class="config-section">
+            <h3>Configuration</h3>
+            <div class="config-grid">
+                <div class="config-item">
+                    <label>Model</label>
+                    <select id="modelSelect">
+                        <option value="sleeker">Moonshine Sleeker</option>
+                        <option value="spindlier">Moonshine Spindlier</option>
+                    </select>
+                </div>
+                <div class="config-item">
+                    <label>ONNX Files URL</label>
+                    <input type="text" id="onnxUrl" placeholder="e.g., ./models or https://..." value="./models">
+                </div>
+                <div class="config-item">
+                    <label>Onset Threshold</label>
+                    <input type="number" id="onsetThreshold" value="0.4" min="0" max="1" step="0.1">
+                </div>
+                <div class="config-item">
+                    <label>Offset Threshold</label>
+                    <input type="number" id="offsetThreshold" value="0.3" min="0" max="1" step="0.1">
+                </div>
+            </div>
+        </div>
+
+        <div class="status-bar">
+            <div class="status-indicator">
+                <div class="status-dot" id="statusDot"></div>
+                <span id="statusText">Ready</span>
+            </div>
+            <div class="controls">
+                <button class="btn-primary" id="startBtn">Start Listening</button>
+                <button class="btn-danger" id="stopBtn" disabled>Stop</button>
+            </div>
+        </div>
+
+        <div class="vad-section">
+            <h3>Voice Activity Detection</h3>
+            <div class="vad-graph">
+                <canvas id="vadCanvas" class="vad-canvas"></canvas>
+            </div>
+            <div class="vad-bar">
+                <span>VAD:</span>
+                <div class="vad-bar-container">
+                    <div class="vad-bar-fill" id="vadBarFill"></div>
+                </div>
+                <span class="vad-value" id="vadValue">0%</span>
+            </div>
+            <div class="pipeline-status">
+                <span>audio_q: <span id="audioQueueSize">0</span></span>
+                <span>features_q: <span id="featuresQueueSize">0</span></span>
+                <span>dropped: <span id="droppedChunks">0</span></span>
+            </div>
+        </div>
+
+        <div class="transcripts-section">
+            <h3>Transcripts</h3>
+            <div class="transcripts-list" id="transcriptsList"></div>
+            <div class="live-caption" id="liveCaption">
+                <div class="live-caption-label">Live Caption</div>
+                <div class="live-caption-text placeholder" id="liveCaptionText">
+                    Waiting for speech...
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/ort.min.js"></script>
+    <script type="module" src="streaming_asr.js"></script>
+</body>
 </html>

streaming_asr.js

@@ -0,0 +1,801 @@
+/**
+ * Streaming ASR Demo - JavaScript Implementation with Web Workers
+ *
+ * Architecture:
+ * - Main thread: Audio capture, VAD, UI updates
+ * - Encoder Worker: Preprocessor + Encoder ONNX inference
+ * - Decoder Worker: Adapter + Decoder ONNX inference
+ */
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+const SAMPLE_RATE = 16000;
+const VAD_CHUNK_SAMPLES = 160;  // 10ms - optimal for TenVAD
+const ASR_CHUNK_SAMPLES = 320;  // 20ms - Moonshine frame size
+const ENCODER_BATCH_SAMPLES = 5120;  // 320ms - batch size for encoder
+
+const PRE_BUFFER_CHUNKS = 15;  // ~300ms at 20ms chunks
+const POST_BUFFER_CHUNKS = 3;  // ~60ms at 20ms chunks
+
+const MODEL_CONFIGS = {
+    sleeker: {
+        dim: 336,
+        dec_dim: 288,
+        depth: 6,
+        encoder_depth: 6,
+        n_past: 16,
+        n_future: 4,
+        nheads: 8,
+        head_dim: 36,
+        vocab_size: 32768
+    },
+    spindlier: {
+        dim: 620,
+        dec_dim: 512,
+        depth: 10,
+        encoder_depth: 10,
+        n_past: 16,
+        n_future: 4,
+        nheads: 8,
+        head_dim: 64,
+        vocab_size: 32768
+    }
+};
+
+// =============================================================================
+// TenVAD - WebAssembly-based Voice Activity Detection
+// =============================================================================
+
+class TenVAD {
+    constructor(hopSize = 160, threshold = 0.5) {
+        this.hopSize = hopSize;
+        this.threshold = threshold;
+        this.module = null;
+        this.vadHandle = null;
+        this.audioPtr = null;
+        this.probPtr = null;
+        this.flagPtr = null;
+        this.ready = false;
+    }
+
+    async init(wasmUrl = './ten_vad.js') {
+        const wasmBinaryUrl = wasmUrl.replace('.js', '.wasm');
+
+        // Dynamic import of the ES module
+        const vadModule = await import(wasmUrl);
+        const createTenVadModule = vadModule.default;
+
+        this.module = await createTenVadModule({
+            locateFile: (path) => {
+                if (path.endsWith('.wasm')) {
+                    return wasmBinaryUrl;
+                }
+                return path;
+            }
+        });
+
+        // Create VAD instance
+        const vadHandlePtr = this.module._malloc(4);
+        const result = this.module._ten_vad_create(vadHandlePtr, this.hopSize, this.threshold);
+
+        if (result !== 0) {
+            this.module._free(vadHandlePtr);
+            throw new Error(`Failed to create TenVAD instance: ${result}`);
+        }
+
+        this.vadHandle = this.module.HEAP32[vadHandlePtr / 4];
+        this.module._free(vadHandlePtr);
+
+        // Allocate buffers
+        this.audioPtr = this.module._malloc(this.hopSize * 2);
+        this.probPtr = this.module._malloc(4);
+        this.flagPtr = this.module._malloc(4);
+
+        this.ready = true;
+    }
+
+    process(audioChunkFloat32) {
+        if (!this.ready) return -1;
+
+        const int16Data = new Int16Array(this.hopSize);
+        for (let i = 0; i < this.hopSize && i < audioChunkFloat32.length; i++) {
+            int16Data[i] = Math.max(-32768, Math.min(32767, Math.round(audioChunkFloat32[i] * 32767)));
+        }
+
+        this.module.HEAP16.set(int16Data, this.audioPtr / 2);
+        this.module._ten_vad_process(this.vadHandle, this.audioPtr, this.hopSize, this.probPtr, this.flagPtr);
+
+        return this.module.HEAPF32[this.probPtr / 4];
+    }
+
+    destroy() {
+        if (!this.ready || !this.module) return;
+
+        this.ready = false;  // Prevent further use
+
+        try {
+            if (this.audioPtr) {
+                this.module._free(this.audioPtr);
+                this.audioPtr = null;
+            }
+            if (this.probPtr) {
+                this.module._free(this.probPtr);
+                this.probPtr = null;
+            }
+            if (this.flagPtr) {
+                this.module._free(this.flagPtr);
+                this.flagPtr = null;
+            }
+            // Skip _ten_vad_destroy as it causes memory access errors
+            // The WASM memory will be cleaned up when the module is garbage collected
+            this.vadHandle = null;
+        } catch (e) {
+            console.warn('TenVAD cleanup error:', e);
+        }
+
+        this.module = null;
+    }
+}
+
+// Fallback simple energy-based VAD
+class SimpleVAD {
+    constructor(sampleRate = 16000, frameSize = 160) {
+        this.frameSize = frameSize;
+        this.energyHistory = [];
+        this.historySize = 50;
+        this.noiseFloor = 0.001;
+        this.ready = true;
+    }
+
+    async init() {}
+
+    process(audioChunk) {
+        let energy = 0;
+        for (let i = 0; i < audioChunk.length; i++) {
+            energy += audioChunk[i] * audioChunk[i];
+        }
+        energy = Math.sqrt(energy / audioChunk.length);
+
+        this.energyHistory.push(energy);
+        if (this.energyHistory.length > this.historySize) {
+            this.energyHistory.shift();
+        }
+
+        if (this.energyHistory.length > 10) {
+            const sorted = [...this.energyHistory].sort((a, b) => a - b);
+            this.noiseFloor = sorted[Math.floor(sorted.length * 0.1)] || 0.001;
+        }
+
+        const snr = energy / (this.noiseFloor + 1e-10);
+        return 1 / (1 + Math.exp(-2 * (snr - 3)));
+    }
+
+    destroy() {}
+}
+
+// =============================================================================
+// Pipelined Streaming ASR with Web Workers
+// =============================================================================
+
+class PipelinedStreamingASR {
+    constructor(config) {
+        this.modelName = config.modelName || 'sleeker';
+        this.onnxUrl = config.onnxUrl || './models';
+        this.onsetThreshold = config.onsetThreshold || 0.5;
+        this.offsetThreshold = config.offsetThreshold || 0.3;
+        this.emaAlpha = config.emaAlpha || 0.3;
+
+        this.cfg = MODEL_CONFIGS[this.modelName];
+
+        // Workers
+        this.encoderWorker = null;
+        this.decoderWorker = null;
+        this.encoderReady = false;
+        this.decoderReady = false;
+
+        // VAD (runs on main thread for low latency)
+        this.vad = null;
+
+        // Audio capture
+        this.audioContext = null;
+        this.sourceNode = null;
+        this.workletNode = null;
+
+        // State
+        this.running = false;
+        this.state = 'idle';
+        this.currentSegmentId = 0;
+        this.emaProb = 0;
+        this.onsetCounter = 0;
+        this.offsetCounter = 0;
+
+        // Buffers
+        this.vadBuffer = [];
+        this.asrBuffer = [];
+        this.preBuffer = [];
+        this.postBufferRemaining = 0;
+        this.encoderBatchBuffer = [];  // Accumulate 320ms before sending to encoder
+
+        // Display state
+        this.vadHistory = [];
+        this.vadUpdateCounter = 0;
+        this.vadUpdateInterval = 5;  // Update display every 5 VAD chunks (50ms)
+
+        // Callbacks
+        this.onVadUpdate = null;
+        this.onTranscript = null;
+        this.onLiveCaption = null;
+        this.onStatusUpdate = null;
+        this.onQueueUpdate = null;
+    }
+
+    async loadModels(progressCallback) {
+        // Initialize VAD
+        try {
+            progressCallback?.('Loading TenVAD...');
+            this.vad = new TenVAD(VAD_CHUNK_SAMPLES, 0.5);
+            await this.vad.init('./ten_vad.js');
+            console.log('Using TenVAD');
+        } catch (e) {
+            console.warn('TenVAD failed, using SimpleVAD:', e.message);
+            this.vad = new SimpleVAD(SAMPLE_RATE, VAD_CHUNK_SAMPLES);
+            await this.vad.init();
+        }
+
+        // Initialize Encoder Worker
+        progressCallback?.('Loading encoder...');
+        await this.initEncoderWorker();
+
+        // Initialize Decoder Worker
+        progressCallback?.('Loading decoder...');
+        await this.initDecoderWorker();
+
+        progressCallback?.('Ready!');
+    }
+
+    initEncoderWorker() {
+        return new Promise((resolve, reject) => {
+            this.encoderWorker = new Worker('./encoder_worker.js');
+
+            this.encoderWorker.onmessage = (e) => {
+                const { type, data } = e.data;
+
+                switch (type) {
+                    case 'ready':
+                        this.encoderReady = true;
+                        resolve();
+                        break;
+                    case 'error':
+                        reject(new Error(e.data.message));
+                        break;
+                    case 'status':
+                        // Progress update from worker
+                        break;
+                    case 'segment_start':
+                        this.decoderWorker?.postMessage({ type: 'segment_start', data: { segmentId: e.data.segmentId } });
+                        break;
+                    case 'segment_end':
+                        this.decoderWorker?.postMessage({ type: 'segment_end', data: { segmentId: e.data.segmentId } });
+                        break;
+                    case 'features':
+                        // Forward features to decoder worker
+                        this.decoderWorker?.postMessage({
+                            type: 'features',
+                            data: {
+                                segmentId: e.data.segmentId,
+                                features: e.data.features,
+                                dims: e.data.dims
+                            }
+                        }, [e.data.features.buffer]);
+                        break;
+                }
+            };
+
+            this.encoderWorker.postMessage({
+                type: 'init',
+                data: {
+                    cfg: this.cfg,
+                    onnxUrl: this.onnxUrl,
+                    modelName: this.modelName
+                }
+            });
+        });
+    }
+
+    initDecoderWorker() {
+        return new Promise((resolve, reject) => {
+            this.decoderWorker = new Worker('./decoder_worker.js');
+
+            this.decoderWorker.onmessage = (e) => {
+                const { type } = e.data;
+
+                switch (type) {
+                    case 'ready':
+                        this.decoderReady = true;
+                        resolve();
+                        break;
+                    case 'error':
+                        reject(new Error(e.data.message));
+                        break;
+                    case 'status':
+                        break;
+                    case 'transcript':
+                        this.onTranscript?.(e.data.text, e.data.segmentId);
+                        break;
+                    case 'live_caption':
+                        this.onLiveCaption?.(e.data.text);
+                        break;
+                }
+            };
+
+            this.decoderWorker.postMessage({
+                type: 'init',
+                data: {
+                    cfg: this.cfg,
+                    onnxUrl: this.onnxUrl,
+                    modelName: this.modelName
+                }
+            });
+        });
+    }
+
+    async start() {
+        if (this.running) return;
+
+        const stream = await navigator.mediaDevices.getUserMedia({
+            audio: {
+                sampleRate: SAMPLE_RATE,
+                channelCount: 1,
+                echoCancellation: false,
+                noiseSuppression: false,
+                autoGainControl: false
+            }
+        });
+
+        this.audioContext = new AudioContext({ sampleRate: SAMPLE_RATE });
+
+        // Check actual sample rate
+        console.log(`Requested sample rate: ${SAMPLE_RATE}, Actual: ${this.audioContext.sampleRate}`);
+        this.sourceNode = this.audioContext.createMediaStreamSource(stream);
+
+        // Use AudioWorklet for better performance
+        try {
+            await this.audioContext.audioWorklet.addModule('./audio_processor.js');
+            this.workletNode = new AudioWorkletNode(this.audioContext, 'audio-processor');
+
+            this.workletNode.port.onmessage = (e) => {
+                if (this.running) {
+                    this.processAudioChunk(e.data.audio);
+                }
+            };
+
+            this.sourceNode.connect(this.workletNode);
+            this.workletNode.connect(this.audioContext.destination);
+        } catch (e) {
+            // Fallback to ScriptProcessor
+            console.warn('AudioWorklet not available, using ScriptProcessor');
+            const bufferSize = 2048;
+            this.scriptNode = this.audioContext.createScriptProcessor(bufferSize, 1, 1);
+
+            this.scriptNode.onaudioprocess = (e) => {
+                if (this.running) {
+                    const inputData = e.inputBuffer.getChannelData(0);
+                    this.processAudioChunk(new Float32Array(inputData));
+                }
+            };
+
+            this.sourceNode.connect(this.scriptNode);
+            this.scriptNode.connect(this.audioContext.destination);
+        }
+
+        this.running = true;
+        this.state = 'idle';
+        this.onsetCounter = 0;
+        this.offsetCounter = 0;
+        this.emaProb = 0;
+
+        this.onStatusUpdate?.('listening', 'Listening...');
+    }
+
+    stop() {
+        this.running = false;
+
+        if (this.workletNode) {
+            this.workletNode.disconnect();
+            this.workletNode = null;
+        }
+        if (this.scriptNode) {
+            this.scriptNode.disconnect();
+            this.scriptNode = null;
+        }
+        if (this.sourceNode) {
+            this.sourceNode.disconnect();
+            this.sourceNode = null;
+        }
+        if (this.audioContext) {
+            this.audioContext.close();
+            this.audioContext = null;
+        }
+        if (this.vad) {
+            this.vad.destroy();
+        }
+        if (this.encoderWorker) {
+            this.encoderWorker.terminate();
+            this.encoderWorker = null;
+        }
+        if (this.decoderWorker) {
+            this.decoderWorker.terminate();
+            this.decoderWorker = null;
+        }
+
+        this.onStatusUpdate?.('idle', 'Stopped');
+    }
+
+    processAudioChunk(audioData) {
+        // Accumulate for VAD (10ms chunks)
+        this.vadBuffer.push(...audioData);
+
+        // Accumulate for ASR (20ms chunks)
+        this.asrBuffer.push(...audioData);
+
+        // Process VAD chunks
+        while (this.vadBuffer.length >= VAD_CHUNK_SAMPLES) {
+            const vadChunk = new Float32Array(this.vadBuffer.splice(0, VAD_CHUNK_SAMPLES));
+            const prob = this.vad.process(vadChunk);
+
+            if (prob >= 0) {
+                this.emaProb = this.emaAlpha * prob + (1 - this.emaAlpha) * this.emaProb;
+
+                // Throttle display updates (every 50ms instead of 10ms)
+                this.vadUpdateCounter++;
+                if (this.vadUpdateCounter >= this.vadUpdateInterval) {
+                    this.vadUpdateCounter = 0;
+                    this.vadHistory.push(this.emaProb);
+                    if (this.vadHistory.length > 100) this.vadHistory.shift();
+                    this.onVadUpdate?.(this.emaProb, this.vadHistory);
+                }
+
+                this.updateSegmentState();
+            }
+        }
+
+        // Extract complete ASR chunks
+        while (this.asrBuffer.length >= ASR_CHUNK_SAMPLES) {
+            const chunkData = this.asrBuffer.splice(0, ASR_CHUNK_SAMPLES);
+            const chunk = new Float32Array(chunkData);
+
+            if (this.state === 'speech') {
+                this.sendAudioToEncoder(chunk);
+            } else {
+                this.preBuffer.push(chunk);
+                if (this.preBuffer.length > PRE_BUFFER_CHUNKS) {
+                    this.preBuffer.shift();
+                }
+
+                if (this.postBufferRemaining > 0) {
+                    this.sendAudioToEncoder(chunk);
+                    this.postBufferRemaining--;
+
+                    if (this.postBufferRemaining === 0) {
+                        this.finalizeSegmentEnd();
+                    }
+                }
+            }
+        }
+    }
+
+    sendAudioToEncoder(chunk, flush = false) {
+        if (!this.encoderWorker || !this.encoderReady) return;
+
+        // Accumulate chunks into batch buffer
+        this.encoderBatchBuffer.push(...chunk);
+
+        // Send when we have 320ms worth of audio, or on flush
+        if (this.encoderBatchBuffer.length >= ENCODER_BATCH_SAMPLES || flush) {
+            if (this.encoderBatchBuffer.length > 0) {
+                const batch = new Float32Array(this.encoderBatchBuffer);
+                this.encoderBatchBuffer = [];
+
+                this.encoderWorker.postMessage({
+                    type: 'audio',
+                    data: {
+                        audio: batch,
+                        segmentId: this.currentSegmentId
+                    }
+                }, [batch.buffer]);
+            }
+        }
+    }
+
+    updateSegmentState() {
+        if (this.state === 'idle') {
+            if (this.emaProb >= this.onsetThreshold) {
+                this.onsetCounter++;
+                if (this.onsetCounter >= 2) {
+                    this.startSegment();
+                }
+            } else {
+                this.onsetCounter = 0;
+            }
+        } else if (this.state === 'speech') {
+            if (this.emaProb < this.offsetThreshold) {
+                this.offsetCounter++;
+                if (this.offsetCounter >= 3) {
+                    this.endSegment();
+                }
+            } else {
+                this.offsetCounter = 0;
+            }
+        }
+    }
+
+    startSegment() {
+        this.currentSegmentId++;
+        this.state = 'speech';
+        this.onsetCounter = 0;
+        this.offsetCounter = 0;
+        this.encoderBatchBuffer = [];  // Reset batch buffer for new segment
+
+        // Tell encoder to start new segment
+        this.encoderWorker?.postMessage({
+            type: 'segment_start',
+            data: { segmentId: this.currentSegmentId }
+        });
+
+        // Drain pre-buffer
+        while (this.preBuffer.length > 0) {
+            const chunk = this.preBuffer.shift();
+            this.sendAudioToEncoder(chunk);
+        }
+
+        this.onStatusUpdate?.('recording', 'Recording...');
+    }
+
+    endSegment() {
+        this.state = 'idle';
+        this.offsetCounter = 0;
+        this.postBufferRemaining = POST_BUFFER_CHUNKS;
+
+        if (this.postBufferRemaining === 0) {
+            this.finalizeSegmentEnd();
+        }
+
+        this.onStatusUpdate?.('listening', 'Listening...');
+    }
+
+    finalizeSegmentEnd() {
+        // Process remaining complete chunks
+        while (this.asrBuffer.length >= ASR_CHUNK_SAMPLES) {
+            const chunkData = this.asrBuffer.splice(0, ASR_CHUNK_SAMPLES);
+            const chunk = new Float32Array(chunkData);
+            this.sendAudioToEncoder(chunk);
+        }
+
+        // Pad and send partial chunk
+        if (this.asrBuffer.length > 0) {
+            const padded = new Float32Array(ASR_CHUNK_SAMPLES);
+            padded.set(this.asrBuffer);
+            this.sendAudioToEncoder(padded);
+        }
+        this.asrBuffer = [];
+
+        // Flush any remaining audio in the batch buffer
+        this.sendAudioToEncoder(new Float32Array(0), true);
+
+        // Signal segment end
+        this.encoderWorker?.postMessage({
+            type: 'segment_end',
+            data: { segmentId: this.currentSegmentId }
+        });
+    }
+}
+
+// =============================================================================
+// UI Controller
+// =============================================================================
+
+class ASRDemoUI {
+    constructor() {
+        this.asr = null;
+        this.vadCanvas = null;
+        this.vadCtx = null;
+
+        this.initElements();
+        this.initCanvas();
+        this.bindEvents();
+    }
+
+    initElements() {
+        this.loadingOverlay = document.getElementById('loadingOverlay');
+        this.loadingText = document.getElementById('loadingText');
+        this.errorMessage = document.getElementById('errorMessage');
+        this.statusDot = document.getElementById('statusDot');
+        this.statusText = document.getElementById('statusText');
+        this.startBtn = document.getElementById('startBtn');
+        this.stopBtn = document.getElementById('stopBtn');
+        this.vadBarFill = document.getElementById('vadBarFill');
+        this.vadValue = document.getElementById('vadValue');
+        this.audioQueueSize = document.getElementById('audioQueueSize');
+        this.featuresQueueSize = document.getElementById('featuresQueueSize');
+        this.droppedChunksEl = document.getElementById('droppedChunks');
+        this.transcriptsList = document.getElementById('transcriptsList');
+        this.liveCaption = document.getElementById('liveCaption');
+        this.liveCaptionText = document.getElementById('liveCaptionText');
+        this.modelSelect = document.getElementById('modelSelect');
+        this.onnxUrl = document.getElementById('onnxUrl');
+        this.onsetThreshold = document.getElementById('onsetThreshold');
+        this.offsetThreshold = document.getElementById('offsetThreshold');
+    }
+
+    initCanvas() {
+        this.vadCanvas = document.getElementById('vadCanvas');
+        this.vadCtx = this.vadCanvas.getContext('2d');
+
+        const rect = this.vadCanvas.getBoundingClientRect();
+        this.vadCanvas.width = rect.width * window.devicePixelRatio;
+        this.vadCanvas.height = rect.height * window.devicePixelRatio;
+        this.vadCtx.scale(window.devicePixelRatio, window.devicePixelRatio);
+    }
+
+    bindEvents() {
+        this.startBtn.addEventListener('click', () => this.handleStart());
+        this.stopBtn.addEventListener('click', () => this.handleStop());
+    }
+
+    async handleStart() {
+        try {
+            this.showLoading('Initializing...');
+
+            const config = {
+                modelName: this.modelSelect.value,
+                onnxUrl: this.onnxUrl.value || './models',
+                onsetThreshold: parseFloat(this.onsetThreshold.value),
+                offsetThreshold: parseFloat(this.offsetThreshold.value)
+            };
+
+            this.asr = new PipelinedStreamingASR(config);
+
+            this.asr.onVadUpdate = (prob, history) => this.updateVadDisplay(prob, history);
+            this.asr.onTranscript = (text, segmentId) => this.addTranscript(text, segmentId);
+            this.asr.onLiveCaption = (text) => this.updateLiveCaption(text);
+            this.asr.onStatusUpdate = (status, text) => this.updateStatus(status, text);
+
+            await this.asr.loadModels((text) => {
+                this.loadingText.textContent = text;
+            });
+
+            await this.asr.start();
+
+            this.hideLoading();
+            this.startBtn.disabled = true;
+            this.stopBtn.disabled = false;
+            this.disableConfig(true);
+
+        } catch (error) {
+            console.error('Start error:', error);
+            this.hideLoading();
+            this.showError(`Failed to start: ${error.message}`);
+        }
+    }
+
+    handleStop() {
+        if (this.asr) {
+            this.asr.stop();
+            this.asr = null;
+        }
+
+        this.startBtn.disabled = false;
+        this.stopBtn.disabled = true;
+        this.disableConfig(false);
+        this.updateStatus('idle', 'Ready');
+    }
+
+    updateVadDisplay(prob, history) {
+        this.vadBarFill.style.width = `${prob * 100}%`;
+        this.vadValue.textContent = `${Math.round(prob * 100)}%`;
+
+        const ctx = this.vadCtx;
+        const rect = this.vadCanvas.getBoundingClientRect();
+        const width = rect.width;
+        const height = rect.height;
+
+        ctx.fillStyle = '#0f0f23';
+        ctx.fillRect(0, 0, width, height);
+
+        if (history.length < 2) return;
+
+        const onsetY = height * (1 - parseFloat(this.onsetThreshold.value));
+        const offsetY = height * (1 - parseFloat(this.offsetThreshold.value));
+
+        ctx.strokeStyle = '#ff444466';
+        ctx.beginPath();
+        ctx.moveTo(0, onsetY);
+        ctx.lineTo(width, onsetY);
+        ctx.stroke();
+
+        ctx.strokeStyle = '#00ff8866';
+        ctx.beginPath();
+        ctx.moveTo(0, offsetY);
+        ctx.lineTo(width, offsetY);
+        ctx.stroke();
+
+        ctx.strokeStyle = '#00d4ff';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+
+        for (let i = 0; i < history.length; i++) {
+            const x = (i / (history.length - 1)) * width;
+            const y = height * (1 - history[i]);
+            if (i === 0) {
+                ctx.moveTo(x, y);
+            } else {
+                ctx.lineTo(x, y);
+            }
+        }
+        ctx.stroke();
+    }
+
+    addTranscript(text, segmentId) {
+        if (!text || !text.trim()) return;
+
+        const item = document.createElement('div');
+        item.className = 'transcript-item';
+        item.innerHTML = `
+            <span class="transcript-duration">#${segmentId}</span>
+            <span class="transcript-text">${this.escapeHtml(text)}</span>
+        `;
+        this.transcriptsList.appendChild(item);
+        this.transcriptsList.scrollTop = this.transcriptsList.scrollHeight;
+    }
+
+    updateLiveCaption(text) {
+        if (text) {
+            this.liveCaptionText.textContent = text;
+            this.liveCaptionText.classList.remove('placeholder');
+            this.liveCaption.classList.add('active');
+        } else {
+            this.liveCaptionText.textContent = 'Waiting for speech...';
+            this.liveCaptionText.classList.add('placeholder');
+            this.liveCaption.classList.remove('active');
+        }
+    }
+
+    updateStatus(status, text) {
+        this.statusDot.className = 'status-dot ' + status;
+        this.statusText.textContent = text;
+    }
+
+    showLoading(text) {
+        this.loadingText.textContent = text;
+        this.loadingOverlay.classList.remove('hidden');
+    }
+
+    hideLoading() {
+        this.loadingOverlay.classList.add('hidden');
+    }
+
+    showError(message) {
+        this.errorMessage.textContent = message;
+        this.errorMessage.classList.add('visible');
+    }
+
+    disableConfig(disabled) {
+        this.modelSelect.disabled = disabled;
+        this.onnxUrl.disabled = disabled;
+        this.onsetThreshold.disabled = disabled;
+        this.offsetThreshold.disabled = disabled;
+    }
+
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+}
+
+// Initialize on page load
+document.addEventListener('DOMContentLoaded', () => {
+    window.asrDemo = new ASRDemoUI();
+});

ten_vad.js

@@ -0,0 +1,30 @@
+
+var createVADModule = (() => {
+  var _scriptDir = import.meta.url;
+  
+  return (
+function(createVADModule) {
+  createVADModule = createVADModule || {};
+
+
+var a;a||(a=typeof createVADModule !== 'undefined' ? createVADModule : {});var k,l;a.ready=new Promise(function(b,c){k=b;l=c});var p=Object.assign({},a),r="object"==typeof window,u="function"==typeof importScripts,v="",w;
+if(r||u)u?v=self.location.href:"undefined"!=typeof document&&document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),0!==v.indexOf("blob:")?v=v.substr(0,v.replace(/[?#].*/,"").lastIndexOf("/")+1):v="",u&&(w=b=>{var c=new XMLHttpRequest;c.open("GET",b,!1);c.responseType="arraybuffer";c.send(null);return new Uint8Array(c.response)});var aa=a.print||console.log.bind(console),x=a.printErr||console.warn.bind(console);Object.assign(a,p);p=null;var y;a.wasmBinary&&(y=a.wasmBinary);
+var noExitRuntime=a.noExitRuntime||!0;"object"!=typeof WebAssembly&&z("no native wasm support detected");var A,B=!1,C="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,D,E,F;function J(){var b=A.buffer;D=b;a.HEAP8=new Int8Array(b);a.HEAP16=new Int16Array(b);a.HEAP32=new Int32Array(b);a.HEAPU8=E=new Uint8Array(b);a.HEAPU16=new Uint16Array(b);a.HEAPU32=F=new Uint32Array(b);a.HEAPF32=new Float32Array(b);a.HEAPF64=new Float64Array(b)}var K=[],L=[],M=[];
+function ba(){var b=a.preRun.shift();K.unshift(b)}var N=0,O=null,P=null;function z(b){if(a.onAbort)a.onAbort(b);b="Aborted("+b+")";x(b);B=!0;b=new WebAssembly.RuntimeError(b+". Build with -sASSERTIONS for more info.");l(b);throw b;}function Q(){return R.startsWith("data:application/octet-stream;base64,")}var R;if(a.locateFile){if(R="ten_vad.wasm",!Q()){var S=R;R=a.locateFile?a.locateFile(S,v):v+S}}else R=(new URL("ten_vad.wasm",import.meta.url)).href;
+function T(){var b=R;try{if(b==R&&y)return new Uint8Array(y);if(w)return w(b);throw"both async and sync fetching of the wasm failed";}catch(c){z(c)}}function ca(){return y||!r&&!u||"function"!=typeof fetch?Promise.resolve().then(function(){return T()}):fetch(R,{credentials:"same-origin"}).then(function(b){if(!b.ok)throw"failed to load wasm binary file at '"+R+"'";return b.arrayBuffer()}).catch(function(){return T()})}function U(b){for(;0<b.length;)b.shift()(a)}
+var da=[null,[],[]],ea={a:function(){z("")},f:function(b,c,m){E.copyWithin(b,c,c+m)},c:function(b){var c=E.length;b>>>=0;if(2147483648<b)return!1;for(var m=1;4>=m;m*=2){var h=c*(1+.2/m);h=Math.min(h,b+100663296);var d=Math;h=Math.max(b,h);d=d.min.call(d,2147483648,h+(65536-h%65536)%65536);a:{try{A.grow(d-D.byteLength+65535>>>16);J();var e=1;break a}catch(W){}e=void 0}if(e)return!0}return!1},e:function(){return 52},b:function(){return 70},d:function(b,c,m,h){for(var d=0,e=0;e<m;e++){var W=F[c>>2],
+X=F[c+4>>2];c+=8;for(var G=0;G<X;G++){var f=E[W+G],H=da[b];if(0===f||10===f){f=H;for(var n=0,q=n+NaN,t=n;f[t]&&!(t>=q);)++t;if(16<t-n&&f.buffer&&C)f=C.decode(f.subarray(n,t));else{for(q="";n<t;){var g=f[n++];if(g&128){var I=f[n++]&63;if(192==(g&224))q+=String.fromCharCode((g&31)<<6|I);else{var Y=f[n++]&63;g=224==(g&240)?(g&15)<<12|I<<6|Y:(g&7)<<18|I<<12|Y<<6|f[n++]&63;65536>g?q+=String.fromCharCode(g):(g-=65536,q+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else q+=String.fromCharCode(g)}f=q}(1===
+b?aa:x)(f);H.length=0}else H.push(f)}d+=X}F[h>>2]=d;return 0}};
+(function(){function b(d){a.asm=d.exports;A=a.asm.g;J();L.unshift(a.asm.h);N--;a.monitorRunDependencies&&a.monitorRunDependencies(N);0==N&&(null!==O&&(clearInterval(O),O=null),P&&(d=P,P=null,d()))}function c(d){b(d.instance)}function m(d){return ca().then(function(e){return WebAssembly.instantiate(e,h)}).then(function(e){return e}).then(d,function(e){x("failed to asynchronously prepare wasm: "+e);z(e)})}var h={a:ea};N++;a.monitorRunDependencies&&a.monitorRunDependencies(N);if(a.instantiateWasm)try{return a.instantiateWasm(h,
+b)}catch(d){x("Module.instantiateWasm callback failed with error: "+d),l(d)}(function(){return y||"function"!=typeof WebAssembly.instantiateStreaming||Q()||"function"!=typeof fetch?m(c):fetch(R,{credentials:"same-origin"}).then(function(d){return WebAssembly.instantiateStreaming(d,h).then(c,function(e){x("wasm streaming compile failed: "+e);x("falling back to ArrayBuffer instantiation");return m(c)})})})().catch(l);return{}})();
+a.___wasm_call_ctors=function(){return(a.___wasm_call_ctors=a.asm.h).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.i).apply(null,arguments)};a._free=function(){return(a._free=a.asm.j).apply(null,arguments)};a._ten_vad_create=function(){return(a._ten_vad_create=a.asm.k).apply(null,arguments)};a._ten_vad_process=function(){return(a._ten_vad_process=a.asm.l).apply(null,arguments)};a._ten_vad_destroy=function(){return(a._ten_vad_destroy=a.asm.m).apply(null,arguments)};
+a._ten_vad_get_version=function(){return(a._ten_vad_get_version=a.asm.n).apply(null,arguments)};var V;P=function fa(){V||Z();V||(P=fa)};
+function Z(){function b(){if(!V&&(V=!0,a.calledRun=!0,!B)){U(L);k(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;){var c=a.postRun.shift();M.unshift(c)}U(M)}}if(!(0<N)){if(a.preRun)for("function"==typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)ba();U(K);0<N||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);b()},1)):b())}}
+if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();Z();
+
+
+  return createVADModule.ready
+}
+);
+})();
+export default createVADModule;

ten_vad.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ec0b9640683987e15a4e54e4ce5642b2447c6e5d82b1be889b5099c75434fc3
+size 283349