@kuralle-syrinx/silero-vad 2.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kuralle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@kuralle-syrinx/silero-vad",
+  "version": "2.1.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./workers": "./src/workers.ts"
+  },
+  "dependencies": {
+    "onnxruntime-node": "1.24.3",
+    "onnxruntime-web": "1.24.3",
+    "@kuralle-syrinx/core": "2.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: MIT
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PipelineBus } from "@kuralle-syrinx/core";
+
+import { SileroVADPlugin } from "./index.js";
+
+// Shared mutable state that the vi.mock factory can close over via vi.hoisted.
+const mockControl = vi.hoisted(() => ({
+  confidence: 0.9,
+  stateCallArgs: [] as Float32Array[],
+}));
+
+vi.mock("onnxruntime-node", () => {
+  // Minimal Tensor stand-in — stores data so session.run() can read it back.
+  function MockTensor(
+    this: { data: unknown },
+    _type: string,
+    data: unknown,
+    _shape: unknown,
+  ) {
+    this.data = data;
+  }
+
+  const run = vi.fn(async (inputs: Record<string, { data: unknown }>) => {
+    const state = inputs["state"]?.data;
+    if (state instanceof Float32Array) {
+      mockControl.stateCallArgs.push(new Float32Array(state));
+    }
+    // Return a distinctive non-zero state so a subsequent reset is detectable.
+    return {
+      output: { data: [mockControl.confidence] },
+      stateN: { data: new Float32Array(2 * 1 * 128).fill(0.5) },
+    };
+  });
+
+  return {
+    InferenceSession: { create: vi.fn(async () => ({ run })) },
+    Tensor: MockTensor,
+  };
+});
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function makeBus(): { bus: PipelineBus; emitted: Array<{ kind: string }> } {
+  const emitted: Array<{ kind: string }> = [];
+  const bus = {
+    push(_route: unknown, pkt: unknown) {
+      emitted.push(pkt as { kind: string });
+    },
+    on(_event: string, _handler: unknown) {
+      return () => {};
+    },
+  } as unknown as PipelineBus;
+  return { bus, emitted };
+}
+
+/** 512-sample (32 ms) silent PCM frame — value irrelevant since model is mocked. */
+function makePcmFrame(): Uint8Array {
+  return new Uint8Array(512 * 2);
+}
+
+async function initPlugin(
+  bus: PipelineBus,
+  config: Record<string, unknown> = {},
+): Promise<SileroVADPlugin> {
+  const plugin = new SileroVADPlugin();
+  await plugin.initialize(bus, { model_path: "/dev/null", ...config });
+  return plugin;
+}
+
+function countKind(emitted: Array<{ kind: string }>, kind: string): number {
+  return emitted.filter((p) => p.kind === kind).length;
+}
+
+function metricValue(
+  emitted: Array<{ kind: string; name?: string; value?: string }>,
+  name: string,
+): string | undefined {
+  return emitted.find((p) => p.kind === "metric.conversation" && p.name === name)?.value;
+}
+
+// ── tests ──────────────────────────────────────────────────────────────────
+
+describe("SileroVADPlugin — G11: periodic state reset gating", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    mockControl.confidence = 0.9;
+    mockControl.stateCallArgs.length = 0;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("does not reset model state mid-speech when the 5 s timer elapses", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    // Frame 1 (T=0): confidence=0.9 → speech_started, vadState=speaking.
+    // stateCallArgs[0] = all-zeros (initial state).
+    await plugin.processAudio(makePcmFrame(), "ctx-1");
+    expect(emitted.some((p) => p.kind === "vad.speech_started")).toBe(true);
+
+    // Advance past the 5 s reset boundary while still speaking.
+    vi.setSystemTime(6000);
+
+    // Frame 2 (T=6000): fix must skip the reset because vadState=speaking.
+    // stateCallArgs[1] = [0.5...] (state updated by frame 1 output).
+    // After this call, state stays [0.5...] (no reset).
+    await plugin.processAudio(makePcmFrame(), "ctx-1");
+
+    // Frame 3 (T=6000): if a reset had fired after frame 2, this call would
+    // receive all-zero state.  With the fix it receives the non-zero value.
+    await plugin.processAudio(makePcmFrame(), "ctx-1");
+
+    expect(emitted.some((p) => p.kind === "vad.speech_ended")).toBe(false);
+
+    // State entering frame 3 must still carry the non-zero value from the mock
+    // (0.5), proving no mid-speech reset occurred.
+    const stateAtFrame3 = mockControl.stateCallArgs[2];
+    expect(stateAtFrame3).toBeDefined();
+    expect(stateAtFrame3!.some((v) => v !== 0)).toBe(true);
+
+    await plugin.close();
+  });
+
+  it("resets model state at the 5 s boundary once speech has ended", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    // Frame 1 (T=0): speech starts.
+    mockControl.confidence = 0.9;
+    await plugin.processAudio(makePcmFrame(), "ctx-2");
+    expect(emitted.some((p) => p.kind === "vad.speech_started")).toBe(true);
+
+    // Switch to silence. silenceFrameTarget = ceil(200/32) = 7; speech ends when
+    // silenceFrames*32 >= minSilenceDurationMs(200) + speechPadMs(80) = 280 ms,
+    // i.e. after 9 consecutive silence frames (9*32=288 >= 280).
+    mockControl.confidence = 0.1;
+    for (let i = 0; i < 9; i++) {
+      await plugin.processAudio(makePcmFrame(), "ctx-2");
+    }
+    expect(emitted.some((p) => p.kind === "vad.speech_ended")).toBe(true);
+
+    // Time has not advanced yet; no reset should have fired (0 - 0 < 5000).
+    // Now advance past the reset window.
+    vi.setSystemTime(6000);
+
+    // Frame at T=6000 (not speaking): reset fires after this run call.
+    await plugin.processAudio(makePcmFrame(), "ctx-2");
+
+    // One more frame: should receive all-zero state because the reset zeroed it.
+    await plugin.processAudio(makePcmFrame(), "ctx-2");
+
+    const lastStateArg = mockControl.stateCallArgs.at(-1);
+    expect(lastStateArg).toBeDefined();
+    expect(lastStateArg!.every((v) => v === 0)).toBe(true);
+
+    await plugin.close();
+  });
+});
+
+describe("SileroVADPlugin — four-state VAD (VE-02)", () => {
+  beforeEach(() => {
+    mockControl.confidence = 0.9;
+    mockControl.stateCallArgs.length = 0;
+  });
+
+  it("vad_flap_rejected: sub-threshold speech burst does not emit speech_started", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus, { speech_start_duration_ms: 96 });
+
+    mockControl.confidence = 0.9;
+    await plugin.processAudio(makePcmFrame(), "ctx-flap");
+
+    mockControl.confidence = 0.1;
+    await plugin.processAudio(makePcmFrame(), "ctx-flap");
+
+    expect(countKind(emitted, "vad.speech_started")).toBe(0);
+    expect(metricValue(emitted, "vad.start_delay_ms")).toBeUndefined();
+
+    await plugin.close();
+  });
+
+  it("vad_full_cycle: sustained speech then silence emits one start and one end", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    mockControl.confidence = 0.9;
+    for (let i = 0; i < 4; i++) {
+      await plugin.processAudio(makePcmFrame(), "ctx-cycle");
+    }
+    expect(countKind(emitted, "vad.speech_started")).toBe(1);
+    expect(metricValue(emitted, "vad.start_delay_ms")).toBe("32");
+
+    mockControl.confidence = 0.1;
+    for (let i = 0; i < 9; i++) {
+      await plugin.processAudio(makePcmFrame(), "ctx-cycle");
+    }
+    expect(countKind(emitted, "vad.speech_ended")).toBe(1);
+    expect(metricValue(emitted, "vad.stop_hangover_ms")).toBe("288");
+
+    await plugin.close();
+  });
+
+  it("vad_resume_no_end: brief silence dip during speech does not emit speech_ended", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    mockControl.confidence = 0.9;
+    await plugin.processAudio(makePcmFrame(), "ctx-resume");
+    expect(countKind(emitted, "vad.speech_started")).toBe(1);
+
+    mockControl.confidence = 0.1;
+    for (let i = 0; i < 3; i++) {
+      await plugin.processAudio(makePcmFrame(), "ctx-resume");
+    }
+    expect(countKind(emitted, "vad.speech_ended")).toBe(0);
+
+    mockControl.confidence = 0.9;
+    await plugin.processAudio(makePcmFrame(), "ctx-resume");
+    expect(countKind(emitted, "vad.speech_ended")).toBe(0);
+    expect(countKind(emitted, "vad.speech_started")).toBe(1);
+
+    await plugin.close();
+  });
+
+  it("default speech_start_duration_ms emits speech_started on the first speech frame", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    mockControl.confidence = 0.9;
+    await plugin.processAudio(makePcmFrame(), "ctx-default");
+
+    expect(countKind(emitted, "vad.speech_started")).toBe(1);
+    expect(metricValue(emitted, "vad.start_delay_ms")).toBe("32");
+
+    await plugin.close();
+  });
+});
+
+describe("SileroVADPlugin — odd byteOffset PCM (browser buffer alignment)", () => {
+  beforeEach(() => {
+    mockControl.confidence = 0.9;
+    mockControl.stateCallArgs.length = 0;
+  });
+
+  it("processes a PCM frame whose byteOffset is odd without throwing", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    // Inbound browser PCM is frequently a Uint8Array view into a pooled Node
+    // Buffer at an ODD byteOffset. `new Int16Array(buffer, oddOffset, …)` throws
+    // "start offset of Int16Array should be a multiple of 2" — this reproduces it.
+    const backing = new Uint8Array(512 * 2 + 1);
+    const oddOffsetFrame = backing.subarray(1); // byteOffset 1 (odd), even length
+    expect(oddOffsetFrame.byteOffset % 2).toBe(1);
+
+    await expect(plugin.processAudio(oddOffsetFrame, "ctx-odd")).resolves.toBeUndefined();
+    expect(emitted.some((p) => p.kind === "vad.error")).toBe(false);
+    // Reached the model and emitted a VAD verdict — proof the frame was processed.
+    expect(emitted.some((p) => p.kind === "vad.speech_started")).toBe(true);
+
+    await plugin.close();
+  });
+});
+
+describe("SileroVADPlugin — telephony saturation hardening", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    mockControl.confidence = 0.9;
+    mockControl.stateCallArgs.length = 0;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  async function frame(plugin: SileroVADPlugin, confidence: number): Promise<void> {
+    mockControl.confidence = confidence;
+    await plugin.processAudio(makePcmFrame(), "ctx-flap");
+  }
+
+  it("absorbs single-frame confidence spikes during stopping so speech still ends", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    await frame(plugin, 0.9); // speech_started → speaking
+    expect(countKind(emitted, "vad.speech_started")).toBe(1);
+
+    // Saturation flap: real silence with an isolated spike in the middle.
+    for (const confidence of [0.2, 0.2, 0.2, 0.2, 0.9, 0.2, 0.2, 0.2, 0.2, 0.2]) {
+      await frame(plugin, confidence);
+    }
+
+    expect(countKind(emitted, "vad.speech_ended")).toBe(1);
+    expect(metricValue(emitted, "vad.stop_hangover_ms")).toBeDefined();
+  });
+
+  it("two consecutive speech frames during stopping resume speaking (real speech is unaffected)", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    await frame(plugin, 0.9); // speaking
+    for (const confidence of [0.2, 0.2, 0.2]) await frame(plugin, confidence); // stopping
+    for (const confidence of [0.9, 0.9]) await frame(plugin, confidence); // sustained speech → resume
+    expect(countKind(emitted, "vad.speech_ended")).toBe(0);
+
+    for (let i = 0; i < 9; i += 1) await frame(plugin, 0.2); // genuine end
+    expect(countKind(emitted, "vad.speech_ended")).toBe(1);
+  });
+
+  it("resets model state during prolonged continuous speech (saturation guard)", async () => {
+    const { bus, emitted } = makeBus();
+    const plugin = await initPlugin(bus);
+
+    await frame(plugin, 0.9); // speaking, state seeded
+    vi.setSystemTime(13_000); // past speaking_state_reset_interval_ms (12 s)
+    await frame(plugin, 0.9); // reset fires after this frame's inference
+    await frame(plugin, 0.9); // this inference must receive the zeroed state
+
+    expect(metricValue(emitted, "vad.state_reset_in_speech")).toBe("1");
+    const stateForThirdFrame = mockControl.stateCallArgs[2]!;
+    expect(stateForThirdFrame.every((value) => value === 0)).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,314 @@
+// SPDX-License-Identifier: MIT
+//
+// Syrinx Kernel v2 — Silero VAD Plugin
+//
+// Runs the Silero ONNX model locally and emits VAD packets through PipelineBus.
+// The model/state handling follows Pipecat's Silero analyzer and RapidAI's
+// session-owned detector pattern: one model instance per session, state reset on
+// lifecycle close, and 16 kHz LINEAR16 mono as the internal audio format.
+
+import { fileURLToPath } from "node:url";
+
+import type { PipelineBus } from "@kuralle-syrinx/core";
+import {
+  ErrorCategory,
+  Route,
+  type PluginConfig,
+  type VadSpeechActivityPacket,
+  type VadSpeechEndedPacket,
+  type VadSpeechStartedPacket,
+  type VoiceErrorPacket,
+  type VoicePlugin,
+  isRecoverable,
+  optionalStringConfig,
+} from "@kuralle-syrinx/core";
+import { pcm16BytesToSamples } from "@kuralle-syrinx/core/audio";
+
+type Ort = typeof import("onnxruntime-node");
+type InferenceSession = import("onnxruntime-node").InferenceSession;
+
+const DEFAULT_MODEL_PATH = fileURLToPath(new URL("../models/silero_vad.onnx", import.meta.url));
+const DEFAULT_SAMPLE_RATE = 16000;
+const WINDOW_SAMPLES_16K = 512;
+const CONTEXT_SAMPLES_16K = 64;
+
+type VadState = "quiet" | "starting" | "speaking" | "stopping";
+
+export class SileroVADPlugin implements VoicePlugin {
+  private bus: PipelineBus | null = null;
+  private session: InferenceSession | null = null;
+  private ort: Ort | null = null;
+  private state = new Float32Array(2 * 1 * 128);
+  private context = new Float32Array(CONTEXT_SAMPLES_16K);
+  private pendingSamples: number[] = [];
+  private vadState: VadState = "quiet";
+  private speechFrames = 0;
+  private confidenceThreshold = 0.5;
+  private minSilenceDurationMs = 200;
+  private speakingStateResetIntervalMs = 12_000;
+  private speechPadMs = 80;
+  private speechStartDurationMs = 32;
+  private sampleRate = DEFAULT_SAMPLE_RATE;
+  private silenceFrames = 0;
+  private stoppingSpikeFrames = 0;
+  private lastResetMs = 0;
+  private disposers: Array<() => void> = [];
+
+  async initialize(bus: PipelineBus, config: PluginConfig): Promise<void> {
+    this.bus = bus;
+    this.confidenceThreshold = readNumber(config, "threshold", 0.5);
+    this.minSilenceDurationMs = readNumber(config, "min_silence_duration_ms", 200);
+    this.speakingStateResetIntervalMs = readNumber(config, "speaking_state_reset_interval_ms", 12_000);
+    this.speechPadMs = readNumber(config, "speech_pad_ms", 80);
+    this.speechStartDurationMs = readNumber(config, "speech_start_duration_ms", 32);
+    this.sampleRate = readNumber(config, "sample_rate", DEFAULT_SAMPLE_RATE);
+    if (this.sampleRate !== 16000) {
+      throw new Error(`SileroVADPlugin requires 16 kHz PCM input, got ${String(this.sampleRate)} Hz`);
+    }
+
+    const modelPath = optionalStringConfig(config, "model_path") ?? DEFAULT_MODEL_PATH;
+    this.ort = await import("onnxruntime-node");
+    this.session = await this.ort.InferenceSession.create(modelPath, {
+      executionProviders: ["cpu"],
+      interOpNumThreads: 1,
+      intraOpNumThreads: 1,
+    });
+    this.resetModelState();
+
+    this.disposers.push(
+      bus.on("vad.audio", async (pkt: unknown) => {
+        const audioPkt = pkt as { audio: Uint8Array; contextId: string };
+        await this.processAudio(audioPkt.audio, audioPkt.contextId);
+      }),
+    );
+  }
+
+  async processAudio(audio: Uint8Array, contextId: string): Promise<void> {
+    if (!this.bus || !this.session || !this.ort) return;
+    if (audio.byteLength % 2 !== 0) {
+      this.emitError(contextId, new Error("VAD audio must be 16-bit PCM with even byte length"));
+      return;
+    }
+
+    // Offset-safe: inbound PCM is often a Uint8Array view into a pooled Node
+    // Buffer at an ODD byteOffset, so `new Int16Array(buffer, byteOffset, …)`
+    // throws "start offset of Int16Array should be a multiple of 2". The canonical
+    // helper reads via DataView and is offset-agnostic.
+    const samples = pcm16BytesToSamples(audio);
+    for (let i = 0; i < samples.length; i += 1) {
+      this.pendingSamples.push(samples[i]! / 32768);
+    }
+
+    while (this.pendingSamples.length >= WINDOW_SAMPLES_16K) {
+      const window = new Float32Array(WINDOW_SAMPLES_16K);
+      for (let i = 0; i < WINDOW_SAMPLES_16K; i += 1) {
+        window[i] = this.pendingSamples.shift()!;
+      }
+      const confidence = await this.runModel(window, contextId);
+      this.emitVadState(confidence, contextId);
+    }
+  }
+
+  async close(): Promise<void> {
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.bus = null;
+    this.session = null;
+    this.ort = null;
+    this.pendingSamples = [];
+    this.resetModelState();
+  }
+
+  private async runModel(window: Float32Array, contextId: string): Promise<number> {
+    if (!this.session || !this.ort) return 0;
+
+    const input = new Float32Array(CONTEXT_SAMPLES_16K + WINDOW_SAMPLES_16K);
+    input.set(this.context, 0);
+    input.set(window, CONTEXT_SAMPLES_16K);
+
+    try {
+      const output = await this.session.run({
+        input: new this.ort.Tensor("float32", input, [1, input.length]),
+        state: new this.ort.Tensor("float32", this.state, [2, 1, 128]),
+        sr: new this.ort.Tensor("int64", BigInt64Array.from([BigInt(this.sampleRate)]), []),
+      });
+
+      const probability = output["output"]?.data?.[0];
+      const nextState = output["stateN"]?.data;
+      if (nextState instanceof Float32Array) {
+        this.state = new Float32Array(nextState);
+      }
+      this.context = input.slice(-CONTEXT_SAMPLES_16K);
+
+      const now = Date.now();
+      if (this.vadState === "quiet" && now - this.lastResetMs >= 5000) {
+        this.resetModelState();
+      }
+
+      return typeof probability === "number" ? probability : 0;
+    } catch (err) {
+      this.emitError(contextId, err instanceof Error ? err : new Error(String(err)));
+      return 0;
+    }
+  }
+
+  private emitVadState(confidence: number, contextId: string): void {
+    if (!this.bus) return;
+
+    const now = Date.now();
+    const isSpeech = confidence >= this.confidenceThreshold;
+    const silenceFrameTarget = Math.max(1, Math.ceil(this.minSilenceDurationMs / 32));
+
+    switch (this.vadState) {
+      case "quiet":
+        if (isSpeech) {
+          this.vadState = "starting";
+          this.speechFrames = 1;
+          this.promoteStartingToSpeakingIfReady(confidence, contextId, now);
+        }
+        break;
+
+      case "starting":
+        if (isSpeech) {
+          if (!this.promoteStartingToSpeakingIfReady(confidence, contextId, now)) {
+            this.speechFrames += 1;
+            this.promoteStartingToSpeakingIfReady(confidence, contextId, now);
+          }
+        } else {
+          this.vadState = "quiet";
+          this.speechFrames = 0;
+        }
+        break;
+
+      case "speaking":
+        if (isSpeech) {
+          // Silero v5 LSTM state saturates on long continuous segments
+          // (telephony monologues): confidence then flaps high through genuine
+          // silence and the end never fires. Periodically reset model state
+          // mid-speech; the spike debounce in "stopping" makes the brief
+          // post-reset confidence dip harmless for real speech.
+          if (now - this.lastResetMs >= this.speakingStateResetIntervalMs) {
+            this.resetModelState();
+            this.bus.push(Route.Main, {
+              kind: "metric.conversation",
+              contextId,
+              timestampMs: now,
+              name: "vad.state_reset_in_speech",
+              value: "1",
+            });
+          }
+          this.emitSpeechActivity(contextId, now);
+        } else {
+          this.vadState = "stopping";
+          this.silenceFrames = 1;
+          this.stoppingSpikeFrames = 0;
+        }
+        break;
+
+      case "stopping":
+        if (isSpeech) {
+          // Single-frame confidence spikes are a known Silero failure mode on
+          // long telephony segments (state saturation flaps high through real
+          // silence). Require sustained speech to leave "stopping" so one
+          // spike cannot reset the silence countdown forever.
+          this.stoppingSpikeFrames += 1;
+          if (this.stoppingSpikeFrames >= 2) {
+            this.vadState = "speaking";
+            this.silenceFrames = 0;
+            this.stoppingSpikeFrames = 0;
+            this.emitSpeechActivity(contextId, now);
+          }
+          break;
+        }
+        this.stoppingSpikeFrames = 0;
+        this.silenceFrames += 1;
+        if (this.silenceFrames * 32 < this.minSilenceDurationMs + this.speechPadMs) break;
+        if (this.silenceFrames < silenceFrameTarget) break;
+
+        {
+          const hangoverMs = this.silenceFrames * 32;
+          this.vadState = "quiet";
+          this.silenceFrames = 0;
+          this.speechFrames = 0;
+          this.stoppingSpikeFrames = 0;
+          const ended: VadSpeechEndedPacket = {
+            kind: "vad.speech_ended",
+            contextId,
+            timestampMs: now,
+          };
+          this.bus.push(Route.Main, ended);
+          this.bus.push(Route.Main, {
+            kind: "metric.conversation",
+            contextId,
+            timestampMs: now,
+            name: "vad.stop_hangover_ms",
+            value: String(hangoverMs),
+          });
+        }
+        break;
+    }
+  }
+
+  private promoteStartingToSpeakingIfReady(
+    confidence: number,
+    contextId: string,
+    now: number,
+  ): boolean {
+    if (!this.bus || this.vadState !== "starting") return false;
+    if (this.speechFrames * 32 < this.speechStartDurationMs) return false;
+
+    const startDelayMs = this.speechFrames * 32;
+    this.vadState = "speaking";
+    this.speechFrames = 0;
+    const started: VadSpeechStartedPacket = {
+      kind: "vad.speech_started",
+      contextId,
+      timestampMs: now,
+      confidence,
+    };
+    this.bus.push(Route.Main, started);
+    this.bus.push(Route.Main, {
+      kind: "metric.conversation",
+      contextId,
+      timestampMs: now,
+      name: "vad.start_delay_ms",
+      value: String(startDelayMs),
+    });
+    this.emitSpeechActivity(contextId, now);
+    return true;
+  }
+
+  private emitSpeechActivity(contextId: string, now: number): void {
+    if (!this.bus) return;
+    const activity: VadSpeechActivityPacket = {
+      kind: "vad.speech_activity",
+      contextId,
+      timestampMs: now,
+      isAsync: true,
+    };
+    this.bus.push(Route.Main, activity);
+  }
+
+  private resetModelState(): void {
+    this.state = new Float32Array(2 * 1 * 128);
+    this.context = new Float32Array(CONTEXT_SAMPLES_16K);
+    this.lastResetMs = Date.now();
+  }
+
+  private emitError(contextId: string, err: Error): void {
+    const packet: VoiceErrorPacket = {
+      kind: "vad.error",
+      contextId,
+      timestampMs: Date.now(),
+      component: "vad",
+      category: ErrorCategory.InvalidInput,
+      cause: err,
+      isRecoverable: isRecoverable(ErrorCategory.InvalidInput),
+    };
+    this.bus?.push(Route.Critical, packet);
+  }
+}
+
+function readNumber(config: PluginConfig, key: string, fallback: number): number {
+  const value = config[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}

package/src/workers.ts

@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: MIT
+
+import type { PipelineBus } from "@kuralle-syrinx/core";
+import {
+  ErrorCategory,
+  Route,
+  type PluginConfig,
+  type VadSpeechActivityPacket,
+  type VadSpeechEndedPacket,
+  type VadSpeechStartedPacket,
+  type VoiceErrorPacket,
+  type VoicePlugin,
+  isRecoverable,
+  optionalStringConfig,
+} from "@kuralle-syrinx/core";
+import { pcm16BytesToSamples } from "@kuralle-syrinx/core/audio";
+
+type Ort = typeof import("onnxruntime-web");
+type InferenceSession = import("onnxruntime-web").InferenceSession;
+
+const DEFAULT_SAMPLE_RATE = 16000;
+const WINDOW_SAMPLES_16K = 512;
+const CONTEXT_SAMPLES_16K = 64;
+
+type VadState = "quiet" | "starting" | "speaking" | "stopping";
+
+export class SileroVADPlugin implements VoicePlugin {
+  private bus: PipelineBus | null = null;
+  private session: InferenceSession | null = null;
+  private ort: Ort | null = null;
+  private state = new Float32Array(2 * 1 * 128);
+  private context = new Float32Array(CONTEXT_SAMPLES_16K);
+  private pendingSamples: number[] = [];
+  private vadState: VadState = "quiet";
+  private speechFrames = 0;
+  private confidenceThreshold = 0.5;
+  private minSilenceDurationMs = 200;
+  private speechPadMs = 80;
+  private speechStartDurationMs = 32;
+  private sampleRate = DEFAULT_SAMPLE_RATE;
+  private silenceFrames = 0;
+  private lastResetMs = 0;
+  private disposers: Array<() => void> = [];
+
+  async initialize(bus: PipelineBus, config: PluginConfig): Promise<void> {
+    this.bus = bus;
+    this.confidenceThreshold = readNumber(config, "threshold", 0.5);
+    this.minSilenceDurationMs = readNumber(config, "min_silence_duration_ms", 200);
+    this.speechPadMs = readNumber(config, "speech_pad_ms", 80);
+    this.speechStartDurationMs = readNumber(config, "speech_start_duration_ms", 32);
+    this.sampleRate = readNumber(config, "sample_rate", DEFAULT_SAMPLE_RATE);
+    if (this.sampleRate !== 16000) {
+      throw new Error(`SileroVADPlugin requires 16 kHz PCM input, got ${String(this.sampleRate)} Hz`);
+    }
+
+    this.ort = await import("onnxruntime-web");
+    this.session = await this.ort.InferenceSession.create(await readModelBytes(config), {
+      executionProviders: ["wasm"],
+    });
+    this.resetModelState();
+
+    this.disposers.push(
+      bus.on("vad.audio", async (pkt: unknown) => {
+        const audioPkt = pkt as { audio: Uint8Array; contextId: string };
+        await this.processAudio(audioPkt.audio, audioPkt.contextId);
+      }),
+    );
+  }
+
+  async processAudio(audio: Uint8Array, contextId: string): Promise<void> {
+    if (!this.bus || !this.session || !this.ort) return;
+    if (audio.byteLength % 2 !== 0) {
+      this.emitError(contextId, new Error("VAD audio must be 16-bit PCM with even byte length"));
+      return;
+    }
+
+    const samples = pcm16BytesToSamples(audio);
+    for (let i = 0; i < samples.length; i += 1) {
+      this.pendingSamples.push(samples[i]! / 32768);
+    }
+
+    while (this.pendingSamples.length >= WINDOW_SAMPLES_16K) {
+      const window = new Float32Array(WINDOW_SAMPLES_16K);
+      for (let i = 0; i < WINDOW_SAMPLES_16K; i += 1) {
+        window[i] = this.pendingSamples.shift()!;
+      }
+      const confidence = await this.runModel(window, contextId);
+      this.emitVadState(confidence, contextId);
+    }
+  }
+
+  async close(): Promise<void> {
+    for (const dispose of this.disposers.splice(0)) dispose();
+    this.bus = null;
+    this.session = null;
+    this.ort = null;
+    this.pendingSamples = [];
+    this.resetModelState();
+  }
+
+  private async runModel(window: Float32Array, contextId: string): Promise<number> {
+    if (!this.session || !this.ort) return 0;
+
+    const input = new Float32Array(CONTEXT_SAMPLES_16K + WINDOW_SAMPLES_16K);
+    input.set(this.context, 0);
+    input.set(window, CONTEXT_SAMPLES_16K);
+
+    try {
+      const output = await this.session.run({
+        input: new this.ort.Tensor("float32", input, [1, input.length]),
+        state: new this.ort.Tensor("float32", this.state, [2, 1, 128]),
+        sr: new this.ort.Tensor("int64", BigInt64Array.from([BigInt(this.sampleRate)]), []),
+      });
+
+      const probability = output["output"]?.data?.[0];
+      const nextState = output["stateN"]?.data;
+      if (nextState instanceof Float32Array) {
+        this.state = new Float32Array(nextState);
+      }
+      this.context = input.slice(-CONTEXT_SAMPLES_16K);
+
+      const now = Date.now();
+      if (this.vadState === "quiet" && now - this.lastResetMs >= 5000) {
+        this.resetModelState();
+      }
+
+      return typeof probability === "number" ? probability : 0;
+    } catch (err) {
+      this.emitError(contextId, err instanceof Error ? err : new Error(String(err)));
+      return 0;
+    }
+  }
+
+  private emitVadState(confidence: number, contextId: string): void {
+    if (!this.bus) return;
+
+    const now = Date.now();
+    const isSpeech = confidence >= this.confidenceThreshold;
+    const silenceFrameTarget = Math.max(1, Math.ceil(this.minSilenceDurationMs / 32));
+
+    switch (this.vadState) {
+      case "quiet":
+        if (isSpeech) {
+          this.vadState = "starting";
+          this.speechFrames = 1;
+          this.promoteStartingToSpeakingIfReady(confidence, contextId, now);
+        }
+        break;
+      case "starting":
+        if (isSpeech) {
+          if (!this.promoteStartingToSpeakingIfReady(confidence, contextId, now)) {
+            this.speechFrames += 1;
+            this.promoteStartingToSpeakingIfReady(confidence, contextId, now);
+          }
+        } else {
+          this.vadState = "quiet";
+          this.speechFrames = 0;
+        }
+        break;
+      case "speaking":
+        if (isSpeech) {
+          this.emitSpeechActivity(contextId, now);
+        } else {
+          this.vadState = "stopping";
+          this.silenceFrames = 1;
+        }
+        break;
+      case "stopping":
+        if (isSpeech) {
+          this.vadState = "speaking";
+          this.silenceFrames = 0;
+          this.emitSpeechActivity(contextId, now);
+        } else {
+          this.silenceFrames += 1;
+          if (this.silenceFrames * 32 < this.minSilenceDurationMs + this.speechPadMs) break;
+          if (this.silenceFrames < silenceFrameTarget) break;
+
+          const hangoverMs = this.silenceFrames * 32;
+          this.vadState = "quiet";
+          this.silenceFrames = 0;
+          this.speechFrames = 0;
+          const ended: VadSpeechEndedPacket = {
+            kind: "vad.speech_ended",
+            contextId,
+            timestampMs: now,
+          };
+          this.bus.push(Route.Main, ended);
+          this.bus.push(Route.Main, {
+            kind: "metric.conversation",
+            contextId,
+            timestampMs: now,
+            name: "vad.stop_hangover_ms",
+            value: String(hangoverMs),
+          });
+        }
+        break;
+    }
+  }
+
+  private promoteStartingToSpeakingIfReady(confidence: number, contextId: string, now: number): boolean {
+    if (!this.bus || this.vadState !== "starting") return false;
+    if (this.speechFrames * 32 < this.speechStartDurationMs) return false;
+
+    const startDelayMs = this.speechFrames * 32;
+    this.vadState = "speaking";
+    this.speechFrames = 0;
+    const started: VadSpeechStartedPacket = {
+      kind: "vad.speech_started",
+      contextId,
+      timestampMs: now,
+      confidence,
+    };
+    this.bus.push(Route.Main, started);
+    this.bus.push(Route.Main, {
+      kind: "metric.conversation",
+      contextId,
+      timestampMs: now,
+      name: "vad.start_delay_ms",
+      value: String(startDelayMs),
+    });
+    this.emitSpeechActivity(contextId, now);
+    return true;
+  }
+
+  private emitSpeechActivity(contextId: string, now: number): void {
+    if (!this.bus) return;
+    const activity: VadSpeechActivityPacket = {
+      kind: "vad.speech_activity",
+      contextId,
+      timestampMs: now,
+      isAsync: true,
+    };
+    this.bus.push(Route.Main, activity);
+  }
+
+  private resetModelState(): void {
+    this.state = new Float32Array(2 * 1 * 128);
+    this.context = new Float32Array(CONTEXT_SAMPLES_16K);
+    this.lastResetMs = Date.now();
+  }
+
+  private emitError(contextId: string, err: Error): void {
+    const packet: VoiceErrorPacket = {
+      kind: "vad.error",
+      contextId,
+      timestampMs: Date.now(),
+      component: "vad",
+      category: ErrorCategory.InvalidInput,
+      cause: err,
+      isRecoverable: isRecoverable(ErrorCategory.InvalidInput),
+    };
+    this.bus?.push(Route.Critical, packet);
+  }
+}
+
+async function readModelBytes(config: PluginConfig): Promise<Uint8Array> {
+  const bytes = config["model_bytes"];
+  if (bytes instanceof Uint8Array) return bytes;
+  if (bytes instanceof ArrayBuffer) return new Uint8Array(bytes);
+  const modelUrl = optionalStringConfig(config, "model_url");
+  if (!modelUrl) {
+    throw new Error("SileroVADPlugin on Workers requires model_bytes or model_url");
+  }
+  const response = await fetch(modelUrl);
+  if (!response.ok) throw new Error(`Failed to fetch Silero model: ${String(response.status)}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+function readNumber(config: PluginConfig, key: string, fallback: number): number {
+  const value = config[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}