omnivad 0.2.5 → 0.2.8

package/dist/index.cjs

@@ -4,12 +4,41 @@ var _documentCurrentScript = typeof document !== 'undefined' ? document.currentS
 // src/wasm-binding.ts
 var _module = null;
 var _loading = null;
+function loadScript(url) {
+  if (typeof globalThis.document === "undefined") {
+    return new Promise((resolve, reject) => {
+      try {
+        const importScripts = globalThis.importScripts;
+        if (typeof importScripts !== "function") {
+          throw new Error(
+            "omnivad: cannot load glue script \u2014 no document and no importScripts"
+          );
+        }
+        importScripts(url);
+        resolve();
+      } catch (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  return new Promise((resolve, reject) => {
+    const s = globalThis.document.createElement("script");
+    s.src = url;
+    s.async = true;
+    s.crossOrigin = "anonymous";
+    s.onload = () => resolve();
+    s.onerror = () => reject(new Error(`Failed to load omnivad glue script: ${url}`));
+    globalThis.document.head.appendChild(s);
+  });
+}
 var SIZEOF_POST_CONFIG = 28;
 var SIZEOF_AED_POST_CONFIG = 3 * SIZEOF_POST_CONFIG;
 var SIZEOF_SEGMENT = 8;
 var SIZEOF_AED_SEGMENT = 16;
+var SIZEOF_CHUNK_CONFIG = 28;
+var SIZEOF_CHUNK = 16;
 var OMNI_ERR_NO_FRAMES = -7;
-var VERSION = "0.2.5";
+var VERSION = "0.2.8";
 var DEFAULT_CDN_BASE = `https://cdn.jsdelivr.net/npm/omnivad@${VERSION}/models`;
 var MODEL_FILES = {
   vad: "vad.omnivad",
@@ -25,22 +54,41 @@ async function initWasm(wasmLocator) {
     if (typeof globalThis.process?.versions?.node === "string") {
       const { createRequire } = await import(
         /* webpackIgnore: true */
+        /* turbopackIgnore: true */
         'module'
       );
-      const { dirname, join } = await import('path');
+      const { dirname, join } = await import(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        'path'
+      );
       const req = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
       const gluePath = req.resolve("../dist/wasm/omnivad.cjs");
       const wasmDir = dirname(gluePath);
       createOmniVAD = req(gluePath);
       defaultLocateFile = (filename) => join(wasmDir, filename);
     } else {
-      const glueUrl = new URL("../dist/wasm/omnivad.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-      const mod = await import(
-        /* webpackIgnore: true */
-        glueUrl.href
-      );
-      createOmniVAD = mod.default || mod;
-      const wasmBaseUrl = new URL("./", glueUrl);
+      let glueUrlStr;
+      if (wasmLocator) {
+        glueUrlStr = wasmLocator("omnivad.js");
+      } else {
+        glueUrlStr = new URL("../dist/wasm/omnivad.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+      }
+      const g = globalThis;
+      let factory = g.createOmniVAD;
+      if (typeof factory !== "function") {
+        await loadScript(glueUrlStr);
+        factory = g.createOmniVAD;
+      }
+      if (typeof factory !== "function") {
+        throw new Error(
+          `omnivad.js loaded from ${glueUrlStr} but globalThis.createOmniVAD is missing`
+        );
+      }
+      createOmniVAD = factory;
+      const baseHref = typeof globalThis.location !== "undefined" ? globalThis.location.href : "file:///";
+      const absGlue = new URL(glueUrlStr, baseHref);
+      const wasmBaseUrl = new URL("./", absGlue);
       defaultLocateFile = (filename) => new URL(filename, wasmBaseUrl).toString();
     }
     const opts = {};
@@ -64,10 +112,19 @@ async function loadModel(modelType, modelUrl, modelData) {
   if (typeof globalThis.process?.versions?.node === "string") {
     const { createRequire } = await import(
       /* webpackIgnore: true */
+      /* turbopackIgnore: true */
       'module'
     );
-    const { dirname, join } = await import('path');
-    const { readFile } = await import('fs/promises');
+    const { dirname, join } = await import(
+      /* webpackIgnore: true */
+      /* turbopackIgnore: true */
+      'path'
+    );
+    const { readFile } = await import(
+      /* webpackIgnore: true */
+      /* turbopackIgnore: true */
+      'fs/promises'
+    );
     const req = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
     const pkgDir = dirname(req.resolve("../package.json"));
     const modelPath = join(pkgDir, "models", filename);
@@ -120,10 +177,86 @@ var DEFAULT_VAD_CONFIG = {
   smoothWindowSize: 5,
   minSpeechFrames: 20,
   minSilenceFrames: 20,
-  maxSpeechFrames: 2e3,
+  maxSpeechFrames: 3e3,
   mergeSilenceFrames: 0,
   extendSpeechFrames: 0
 };
+var OMNI_CHUNK_GREEDY = 0;
+var OMNI_CHUNK_LONGEST_GAP = 1;
+var DEFAULT_CHUNK_CONFIG = {
+  maxChunkSecs: 30,
+  maxGapSecs: Infinity,
+  padOnsetSecs: 0.04,
+  padOffsetSecs: 0.04,
+  minSpeechSecs: 0,
+  minSilenceSecs: 0.2,
+  // matches VAD minSilenceFrames=20 @ 10ms shift
+  mode: "greedy"
+};
+function modeToInt(m) {
+  switch (m) {
+    case "greedy":
+      return OMNI_CHUNK_GREEDY;
+    case "longest_gap":
+      return OMNI_CHUNK_LONGEST_GAP;
+    default:
+      throw new Error(`Unknown chunking mode: ${String(m)}`);
+  }
+}
+function writeChunkConfig(M, ptr, cfg) {
+  M.setValue(ptr + 0, cfg.maxChunkSecs, "float");
+  M.setValue(ptr + 4, cfg.maxGapSecs, "float");
+  M.setValue(ptr + 8, cfg.padOnsetSecs, "float");
+  M.setValue(ptr + 12, cfg.padOffsetSecs, "float");
+  M.setValue(ptr + 16, cfg.minSpeechSecs, "float");
+  M.setValue(ptr + 20, cfg.minSilenceSecs, "float");
+  M.setValue(ptr + 24, modeToInt(cfg.mode), "i32");
+}
+function chunkMerge(M, segments, config) {
+  const numSegments = segments.length;
+  const segPtr = numSegments > 0 ? M._malloc(numSegments * SIZEOF_SEGMENT) : 0;
+  const cfgPtr = M._malloc(SIZEOF_CHUNK_CONFIG);
+  const outPtrPtr = M._malloc(4);
+  const outCountPtr = M._malloc(4);
+  try {
+    for (let i = 0; i < numSegments; i++) {
+      const base = segPtr + i * SIZEOF_SEGMENT;
+      M.setValue(base + 0, segments[i][0], "float");
+      M.setValue(base + 4, segments[i][1], "float");
+    }
+    writeChunkConfig(M, cfgPtr, config);
+    M.setValue(outPtrPtr, 0, "i32");
+    M.setValue(outCountPtr, 0, "i32");
+    const rc = M.ccall(
+      "omni_merge_chunks",
+      "number",
+      ["number", "number", "number", "number", "number"],
+      [segPtr, numSegments, cfgPtr, outPtrPtr, outCountPtr]
+    );
+    if (rc !== 0) {
+      throw new Error(`omni_merge_chunks failed: ${readNativeError(M, rc)}`);
+    }
+    const count = M.getValue(outCountPtr, "i32");
+    const chunkPtr = M.getValue(outPtrPtr, "i32");
+    const chunks = [];
+    for (let i = 0; i < count; i++) {
+      const base = chunkPtr + i * SIZEOF_CHUNK;
+      chunks.push({
+        start: M.getValue(base + 0, "float"),
+        end: M.getValue(base + 4, "float"),
+        segStartIdx: M.getValue(base + 8, "i32"),
+        segCount: M.getValue(base + 12, "i32")
+      });
+    }
+    if (chunkPtr) M._free(chunkPtr);
+    return chunks;
+  } finally {
+    if (segPtr) M._free(segPtr);
+    M._free(cfgPtr);
+    M._free(outPtrPtr);
+    M._free(outCountPtr);
+  }
+}
 function vadCreate(M, modelBuffer) {
   const bytes = new Uint8Array(modelBuffer);
   const ptr = M._malloc(bytes.length);
@@ -228,24 +361,49 @@ function aedDetect(M, handle, audioPtr, numSamples, cfg, format = "f32") {
 function aedDestroy(M, handle) {
   M.ccall("omni_aed_destroy", null, ["number"], [handle]);
 }
-function streamVadCreate(M, modelBuffer, threshold = 0.5) {
+var DEFAULT_STREAM_VAD_CONFIG = {
+  threshold: 0.5,
+  smoothWindowSize: 5,
+  padStartFrame: 5,
+  minSpeechFrame: 8,
+  maxSpeechFrame: 2e3,
+  minSilenceFrame: 20
+};
+var SIZEOF_STREAM_VAD_CONFIG = 24;
+function writeStreamVadConfig(M, ptr, cfg) {
+  M.setValue(ptr + 0, cfg.threshold, "float");
+  M.setValue(ptr + 4, cfg.smoothWindowSize, "i32");
+  M.setValue(ptr + 8, cfg.padStartFrame, "i32");
+  M.setValue(ptr + 12, cfg.minSpeechFrame, "i32");
+  M.setValue(ptr + 16, cfg.maxSpeechFrame, "i32");
+  M.setValue(ptr + 20, cfg.minSilenceFrame, "i32");
+}
+function streamVadCreate(M, modelBuffer, config = {}) {
+  const overrides = Object.fromEntries(
+    Object.entries(config).filter(([, v]) => v !== void 0)
+  );
+  const cfg = { ...DEFAULT_STREAM_VAD_CONFIG, ...overrides };
   const bytes = new Uint8Array(modelBuffer);
-  const ptr = M._malloc(bytes.length);
-  M.HEAPU8.set(bytes, ptr);
+  const dataPtr = M._malloc(bytes.length);
+  M.HEAPU8.set(bytes, dataPtr);
+  const cfgPtr = M._malloc(SIZEOF_STREAM_VAD_CONFIG);
   try {
+    writeStreamVadConfig(M, cfgPtr, cfg);
     return createModel(
       M,
       "omni_stream_vad_create_from_buffer",
       ["number", "number", "number"],
-      [ptr, bytes.length, threshold],
+      [dataPtr, bytes.length, cfgPtr],
       "StreamVAD"
     );
   } finally {
-    M._free(ptr);
+    M._free(dataPtr);
+    M._free(cfgPtr);
   }
 }
+var SIZEOF_STREAM_VAD_RESULT = 24;
 function streamVadProcess(M, handle, pcm16Ptr, numSamples) {
-  const resultPtr = M._malloc(12);
+  const resultPtr = M._malloc(SIZEOF_STREAM_VAD_RESULT);
   try {
     const ret = M.ccall(
       "omni_stream_vad_process",
@@ -256,9 +414,14 @@ function streamVadProcess(M, handle, pcm16Ptr, numSamples) {
     if (ret === OMNI_ERR_NO_FRAMES) return null;
     if (ret !== 0) throw new Error(`StreamVAD process failed: ${ret}`);
     return {
-      confidence: M.getValue(resultPtr, "float"),
-      isSpeech: M.getValue(resultPtr + 4, "i8") !== 0,
-      frameOffset: M.getValue(resultPtr + 8, "i32")
+      confidence: M.getValue(resultPtr + 0, "float"),
+      smoothedProb: M.getValue(resultPtr + 4, "float"),
+      isSpeech: M.getValue(resultPtr + 8, "i8") !== 0,
+      isSpeechStart: M.getValue(resultPtr + 9, "i8") !== 0,
+      isSpeechEnd: M.getValue(resultPtr + 10, "i8") !== 0,
+      frameIdx: M.getValue(resultPtr + 12, "i32"),
+      speechStartFrame: M.getValue(resultPtr + 16, "i32"),
+      speechEndFrame: M.getValue(resultPtr + 20, "i32")
     };
   } finally {
     M._free(resultPtr);
@@ -357,8 +520,6 @@ function int16ToNormalizedFloat32(i16) {
 var SAMPLE_RATE2 = 16e3;
 var OmniStreamVAD = class _OmniStreamVAD {
   constructor(handle) {
-    this.inSpeech = false;
-    this.speechStartFrame = 0;
     this.handle = handle;
   }
   /**
@@ -369,8 +530,14 @@ var OmniStreamVAD = class _OmniStreamVAD {
     await initWasm();
     const M = getModule();
     const modelBuffer = await loadModel("stream-vad", options.modelUrl, options.modelData);
-    const threshold = options.speechThreshold ?? 0.5;
-    const handle = streamVadCreate(M, modelBuffer, threshold);
+    const handle = streamVadCreate(M, modelBuffer, {
+      threshold: options.threshold,
+      smoothWindowSize: options.smoothWindowSize,
+      padStartFrame: options.padStartFrame,
+      minSpeechFrame: options.minSpeechFrame,
+      maxSpeechFrame: options.maxSpeechFrame,
+      minSilenceFrame: options.minSilenceFrame
+    });
     return new _OmniStreamVAD(handle);
   }
   /**
@@ -388,6 +555,10 @@ var OmniStreamVAD = class _OmniStreamVAD {
   /**
    * Process one frame of audio (160 int16 samples = 10ms @ 16kHz).
    * Returns null until enough audio is accumulated.
+   *
+   * Segment-boundary events (isSpeechStart / isSpeechEnd and the matching
+   * speech_*_frame indices) come straight from the C-layer state machine
+   * (bit-identical to upstream FireRedVAD) — the wrapper is just a marshaller.
    */
   processFrame(pcm160) {
     const M = getModule();
@@ -396,28 +567,16 @@ var OmniStreamVAD = class _OmniStreamVAD {
     heap16.set(pcm160);
     try {
       const result = streamVadProcess(M, this.handle, ptr, pcm160.length);
-      if (!result || result.frameOffset === 0) return null;
-      const frameIndex = result.frameOffset;
-      const isSpeechStart = result.isSpeech && !this.inSpeech;
-      const isSpeechEnd = !result.isSpeech && this.inSpeech;
-      if (isSpeechStart) {
-        this.speechStartFrame = frameIndex;
-      }
-      const activeSpeechStartFrame = isSpeechEnd ? this.speechStartFrame : result.isSpeech ? this.speechStartFrame : 0;
-      const speechEndFrame = isSpeechEnd ? Math.max(1, frameIndex - 1) : 0;
-      this.inSpeech = result.isSpeech;
-      if (isSpeechEnd) {
-        this.speechStartFrame = 0;
-      }
+      if (!result) return null;
       return {
         confidence: result.confidence,
-        smoothedConfidence: result.confidence,
+        smoothedProb: result.smoothedProb,
         isSpeech: result.isSpeech,
-        frameIndex,
-        isSpeechStart,
-        isSpeechEnd,
-        speechStartFrame: activeSpeechStartFrame,
-        speechEndFrame
+        frameIndex: result.frameIdx,
+        isSpeechStart: result.isSpeechStart,
+        isSpeechEnd: result.isSpeechEnd,
+        speechStartFrame: result.speechStartFrame,
+        speechEndFrame: result.speechEndFrame
       };
     } finally {
       M._free(ptr);
@@ -456,11 +615,9 @@ var OmniStreamVAD = class _OmniStreamVAD {
       M._free(framesPtr);
     }
   }
-  /** Reset all internal state. */
+  /** Reset all internal state (model cache, audio buffer, postprocessor). */
   reset() {
     streamVadReset(getModule(), this.handle);
-    this.inSpeech = false;
-    this.speechStartFrame = 0;
   }
   /** Release native resources. */
   dispose() {
@@ -468,8 +625,6 @@ var OmniStreamVAD = class _OmniStreamVAD {
       streamVadDestroy(getModule(), this.handle);
       this.handle = 0;
     }
-    this.inSpeech = false;
-    this.speechStartFrame = 0;
   }
 };
 function int16ToFloat32(i16) {
@@ -583,7 +738,30 @@ function computeCoverageRatios(events, duration) {
   return ratios;
 }
 
+// src/chunking.ts
+async function mergeChunks(segments, options = {}) {
+  await initWasm();
+  const M = getModule();
+  const cfg = {
+    maxChunkSecs: options.maxChunkSecs ?? DEFAULT_CHUNK_CONFIG.maxChunkSecs,
+    maxGapSecs: options.maxGapSecs ?? DEFAULT_CHUNK_CONFIG.maxGapSecs,
+    padOnsetSecs: options.padOnsetSecs ?? DEFAULT_CHUNK_CONFIG.padOnsetSecs,
+    padOffsetSecs: options.padOffsetSecs ?? DEFAULT_CHUNK_CONFIG.padOffsetSecs,
+    minSpeechSecs: options.minSpeechSecs ?? DEFAULT_CHUNK_CONFIG.minSpeechSecs,
+    minSilenceSecs: options.minSilenceSecs ?? DEFAULT_CHUNK_CONFIG.minSilenceSecs,
+    mode: options.mode ?? DEFAULT_CHUNK_CONFIG.mode
+  };
+  const records = chunkMerge(M, segments, cfg);
+  return records.map((r) => ({
+    start: r.start,
+    end: r.end,
+    segStartIdx: r.segStartIdx,
+    segCount: r.segCount
+  }));
+}
+
 exports.DEFAULT_CDN_BASE = DEFAULT_CDN_BASE;
+exports.DEFAULT_CHUNK_CONFIG = DEFAULT_CHUNK_CONFIG;
 exports.FireRedAED = OmniAED;
 exports.FireRedStreamVAD = OmniStreamVAD;
 exports.FireRedVAD = OmniVAD;
@@ -594,5 +772,6 @@ exports.OmniVAD = OmniVAD;
 exports.VERSION = VERSION;
 exports.initWasm = initWasm;
 exports.loadModel = loadModel;
+exports.mergeChunks = mergeChunks;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map