@xrkseek/harness 0.7.6 → 0.7.8

package/node_modules/sherpa-onnx-node/non-streaming-asr.js

@@ -0,0 +1,158 @@
+/** @typedef {import('./types').OfflineStreamObject} OfflineStreamObject */
+/** @typedef {import('./types').OfflineStreamHandle} OfflineStreamHandle */
+/** @typedef {import('./types').OfflineRecognizerHandle} OfflineRecognizerHandle */
+/** @typedef {import('./types').Waveform} Waveform */
+/**
+ * @typedef {import('./types').OfflineRecognizerConfig} OfflineRecognizerConfig
+ */
+/**
+ * @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult
+ */
+
+const addon = require('./addon.js');
+
+/**
+ * Internal symbol to mark async-created recognizers.
+ * Not accessible unless someone has a reference to this Symbol.
+ */
+const kFromAsyncFactory = Symbol('OfflineRecognizer.fromAsync');
+
+/**
+ * OfflineStream represents a synchronous offline audio stream.
+ */
+class OfflineStream {
+  /**
+   * @param {OfflineStreamObject|Object} handle
+   */
+  constructor(handle) {
+    this.handle = handle;
+  }
+
+  /**
+   * Accept a chunk of waveform samples.
+   * @param {Waveform} obj - { samples: Float32Array, sampleRate: number }
+   */
+  acceptWaveform(obj) {
+    addon.acceptWaveformOffline(this.handle, obj);
+  }
+
+  /**
+   * Set a string option on the underlying offline stream.
+   * @param {string} key
+   * @param {string} value
+   */
+  setOption(key, value) {
+    addon.offlineStreamSetOption(this.handle, key, value);
+  }
+}
+
+/**
+ * OfflineRecognizer wraps the native offline recognizer.
+ */
+class OfflineRecognizer {
+  /**
+   * Constructor (SYNC path).
+   *
+   * Users call:
+   *   new OfflineRecognizer(config)
+   *
+   * Async factory calls this with an internal descriptor.
+   *
+   * @param {OfflineRecognizerConfig | Object} configOrInternal
+   */
+  constructor(configOrInternal) {
+    // ----- async factory path -----
+    if (configOrInternal && typeof configOrInternal === 'object' &&
+        configOrInternal[kFromAsyncFactory]) {
+      this.handle = configOrInternal.handle;
+      this.config = configOrInternal.config;
+      return;
+    }
+
+    // ----- sync constructor path -----
+    this.config = configOrInternal;
+    this.handle = addon.createOfflineRecognizer(this.config);
+  }
+
+  /**
+   * Create an OfflineRecognizer asynchronously (non-blocking).
+   *
+   * @param {OfflineRecognizerConfig} config
+   * @returns {Promise<OfflineRecognizer>}
+   */
+  static async createAsync(config) {
+    const handle = await addon.createOfflineRecognizerAsync(config);
+
+    return new OfflineRecognizer({
+      [kFromAsyncFactory]: true,
+      handle,
+      config,
+    });
+  }
+
+  /**
+   * Create a new OfflineStream bound to this recognizer.
+   *
+   * The optional hotwords argument enables contextual biasing for this
+   * stream only. Hotwords are supported only by transducer models decoded
+   * with decodingMethod 'modified_beam_search'. Separate multiple phrases
+   * with '/', and optionally append a per-phrase boosting score, e.g.
+   * 'PHOEBE :2.0/DON QUIXOTE'. When modelConfig.modelingUnit and
+   * modelConfig.bpeVocab are set, phrases are given as normal words;
+   * otherwise each phrase must be a sequence of tokens from tokens.txt
+   * separated by spaces. See also
+   * https://k2-fsa.github.io/sherpa/onnx/hotwords/index.html
+   *
+   * @param {string} [hotwords] Optional hotwords for this stream.
+   * @returns {OfflineStream}
+   */
+  createStream(hotwords) {
+    const handle = hotwords === undefined ?
+        addon.createOfflineStream(this.handle) :
+        addon.createOfflineStream(this.handle, hotwords);
+    return new OfflineStream(handle);
+  }
+
+  /**
+   * Replace the recognizer config at runtime.
+   * @param {OfflineRecognizerConfig} config
+   */
+  setConfig(config) {
+    this.config = config;
+    addon.offlineRecognizerSetConfig(this.handle, config);
+  }
+
+  /**
+   * Decode an offline stream (synchronous).
+   * @param {OfflineStream} stream
+   */
+  decode(stream) {
+    addon.decodeOfflineStream(this.handle, stream.handle);
+  }
+
+  /**
+   * Decode an offline stream asynchronously (non-blocking).
+   * @param {OfflineStream} stream
+   * @returns {Promise<OfflineRecognizerResult>}
+   */
+  async decodeAsync(stream) {
+    const jsonStr =
+        await addon.decodeOfflineStreamAsync(this.handle, stream.handle);
+    return JSON.parse(jsonStr);
+  }
+
+  /**
+   * Get recognition result for a stream.
+   * @param {OfflineStream} stream
+   * @returns {OfflineRecognizerResult}
+   */
+  getResult(stream) {
+    const jsonStr = addon.getOfflineStreamResultAsJson(stream.handle);
+    return JSON.parse(jsonStr);
+  }
+}
+
+module.exports = {
+  OfflineRecognizer,
+  OfflineStream,
+};

package/node_modules/sherpa-onnx-node/non-streaming-speaker-diarization.js

@@ -0,0 +1,38 @@
+/** @typedef {import('./types').OfflineSpeakerDiarizationConfig} OfflineSpeakerDiarizationConfig */
+/** @typedef {import('./types').OfflineSpeakerDiarizationHandle} OfflineSpeakerDiarizationHandle */
+/** @typedef {import('./types').SpeakerDiarizationSegment} SpeakerDiarizationSegment */
+
+const addon = require('./addon.js');
+
+class OfflineSpeakerDiarization {
+  /**
+   * @param {OfflineSpeakerDiarizationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflineSpeakerDiarization(config);
+    this.config = config;
+
+    this.sampleRate = addon.getOfflineSpeakerDiarizationSampleRate(this.handle);
+  }
+
+  /**
+   * @param {Float32Array} samples - 1-D float32 array in [-1, 1]
+   * @returns {SpeakerDiarizationSegment[]}
+   */
+  process(samples) {
+    return addon.offlineSpeakerDiarizationProcess(this.handle, samples);
+  }
+
+  /**
+   * Set clustering configuration.
+   * @param {{clustering: import('./types').FastClusteringConfig}} config
+   */
+  setConfig(config) {
+    addon.offlineSpeakerDiarizationSetConfig(this.handle, config);
+    this.config.clustering = config.clustering;
+  }
+}
+
+module.exports = {
+  OfflineSpeakerDiarization,
+} 

package/node_modules/sherpa-onnx-node/non-streaming-speech-denoiser.js

@@ -0,0 +1,32 @@
+/** @typedef {import('./types').OfflineSpeechDenoiserConfig} OfflineSpeechDenoiserConfig */
+/** @typedef {import('./types').OfflineSpeechDenoiserHandle} OfflineSpeechDenoiserHandle */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+/** @typedef {import('./types').AudioProcessRequest} AudioProcessRequest */
+
+const addon = require('./addon.js');
+
+class OfflineSpeechDenoiser {
+  /**
+   * @param {OfflineSpeechDenoiserConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflineSpeechDenoiser(config);
+    this.config = config;
+
+    this.sampleRate =
+        addon.offlineSpeechDenoiserGetSampleRateWrapper(this.handle);
+  }
+
+  /**
+   * Run denoiser synchronously.
+   * @param {AudioProcessRequest} obj - { samples: Float32Array, sampleRate: number, enableExternalBuffer?: boolean }
+   * @returns {GeneratedAudio}
+   */
+  run(obj) {
+    return addon.offlineSpeechDenoiserRunWrapper(this.handle, obj);
+  }
+}
+
+module.exports = {
+  OfflineSpeechDenoiser,
+} 

package/node_modules/sherpa-onnx-node/non-streaming-tts.js

@@ -0,0 +1,117 @@
+/** @typedef {import('./types').OfflineTtsConfig} OfflineTtsConfig */
+/** @typedef {import('./types').OfflineTtsHandle} OfflineTtsHandle */
+/** @typedef {import('./types').TtsRequest} TtsRequest */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+
+const addon = require('./addon.js');
+
+/**
+ * Internal symbol to mark async-created TTS instances.
+ */
+const kFromAsyncFactory = Symbol('OfflineTts.fromAsync');
+
+
+class GenerationConfig {
+  constructor(opts = {}) {
+    Object.assign(this, opts);
+  }
+}
+
+
+class OfflineTts {
+  /**
+   * Constructor (sync path).
+   *
+   * Users call:
+   *   new OfflineTts(config)
+   *
+   * Async factory calls this with an internal descriptor.
+   *
+   * @param {OfflineTtsConfig|Object} configOrInternal
+   */
+  constructor(configOrInternal) {
+    if (configOrInternal && typeof configOrInternal === 'object' &&
+        configOrInternal[kFromAsyncFactory]) {
+      // ----- async factory path -----
+      this.handle = configOrInternal.handle;
+      this.config = configOrInternal.config;
+    } else {
+      // ----- sync constructor path -----
+      this.config = configOrInternal;
+      this.handle = addon.createOfflineTts(this.config);
+    }
+
+    // Common initialization
+    this.numSpeakers = addon.getOfflineTtsNumSpeakers(this.handle);
+    this.sampleRate = addon.getOfflineTtsSampleRate(this.handle);
+    this.lang = addon.getOfflineTtsLang(this.handle);
+  }
+
+  /**
+   * Create an OfflineTts asynchronously (non-blocking).
+   * @param {OfflineTtsConfig} config
+   * @returns {Promise<OfflineTts>}
+   */
+  static async createAsync(config) {
+    const handle = await addon.createOfflineTtsAsync(config);
+    return new OfflineTts({
+      [kFromAsyncFactory]: true,
+      handle,
+      config,
+    });
+  }
+
+  /**
+   * Generate audio synchronously.
+   * @param {TtsRequest} obj
+   * @returns {GeneratedAudio}
+   */
+  generate(obj) {
+    if (!obj || typeof obj !== 'object') {
+      throw new TypeError('generate() expects an object');
+    }
+
+    // If generationConfig is present, use new API
+    if (obj.generationConfig !== undefined) {
+      return addon.offlineTtsGenerateWithConfig(this.handle, obj);
+    }
+
+    // Fallback to legacy path
+    return addon.offlineTtsGenerate(this.handle, obj);
+  }
+  /**
+   * Generate audio asynchronously with optional generationConfig and progress
+   * callback
+   *
+   * The progress callback receives streaming audio chunks.
+   *
+   * @param {TtsRequest & { generationConfig?: GenerationConfig, onProgress?: (info: {
+   *     samples: Float32Array, progress: number }) => number | boolean | void
+   *     }} obj
+   * @returns {Promise<GeneratedAudio>}
+   */
+  generateAsync(obj) {
+    const {onProgress, ...rest} = obj;
+
+    const hasConfig = obj.generationConfig !== undefined;
+
+    const fn = hasConfig ? addon.offlineTtsGenerateAsyncWithConfig :
+                           addon.offlineTtsGenerateAsync;
+
+    return fn(this.handle, {
+      ...rest,
+      callback: typeof onProgress === 'function' ?
+          (info) => {
+            const ret = onProgress(info);
+            return ret === 0 || ret === false ? 0 : 1;
+          } :
+          undefined,
+    });
+  }
+}
+
+
+module.exports = {
+  OfflineTts,
+  GenerationConfig,
+}

package/node_modules/sherpa-onnx-node/online-speech-denoiser.js

@@ -0,0 +1,46 @@
+/** @typedef {import('./types').OnlineSpeechDenoiserConfig} OnlineSpeechDenoiserConfig */
+/** @typedef {import('./types').OnlineSpeechDenoiserHandle} OnlineSpeechDenoiserHandle */
+/** @typedef {import('./types').GeneratedAudio} GeneratedAudio */
+/** @typedef {import('./types').AudioProcessRequest} AudioProcessRequest */
+
+const addon = require('./addon.js');
+
+class OnlineSpeechDenoiser {
+  /**
+   * @param {OnlineSpeechDenoiserConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOnlineSpeechDenoiser(config);
+    this.config = config;
+
+    this.sampleRate =
+        addon.onlineSpeechDenoiserGetSampleRateWrapper(this.handle);
+    this.frameShiftInSamples =
+        addon.onlineSpeechDenoiserGetFrameShiftInSamplesWrapper(this.handle);
+  }
+
+  /**
+   * @param {AudioProcessRequest} obj
+   * @returns {GeneratedAudio}
+   */
+  run(obj) {
+    return addon.onlineSpeechDenoiserRunWrapper(this.handle, obj);
+  }
+
+  /**
+   * @param {boolean} [enableExternalBuffer=true]
+   * @returns {GeneratedAudio}
+   */
+  flush(enableExternalBuffer = true) {
+    return addon.onlineSpeechDenoiserFlushWrapper(
+        this.handle, enableExternalBuffer);
+  }
+
+  reset() {
+    addon.onlineSpeechDenoiserResetWrapper(this.handle);
+  }
+}
+
+module.exports = {
+  OnlineSpeechDenoiser,
+};

package/node_modules/sherpa-onnx-node/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "sherpa-onnx-node",
+  "version": "2.0.1",
+  "description": "Speech-to-text, text-to-speech, speaker diarization, and speech enhancement using Next-gen Kaldi without internet connection",
+  "main": "sherpa-onnx.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/csukuangfj/sherpa-onnx.git"
+  },
+  "keywords": [
+    "speech to text",
+    "text to speech",
+    "transcription",
+    "real-time speech recognition",
+    "without internet connection",
+    "locally",
+    "local",
+    "embedded systems",
+    "open source",
+    "diarization",
+    "speaker diarization",
+    "speaker recognition",
+    "speaker",
+    "speaker segmentation",
+    "speaker verification",
+    "spoken language identification",
+    "sherpa",
+    "zipformer",
+    "asr",
+    "tts",
+    "stt",
+    "c++",
+    "onnxruntime",
+    "onnx",
+    "ai",
+    "next-gen kaldi",
+    "offline",
+    "privacy",
+    "open source",
+    "streaming speech recognition",
+    "speech",
+    "recognition",
+    "vad",
+    "node-addon-api",
+    "speaker id",
+    "language id",
+    "speech enhancement",
+    "denoising"
+  ],
+  "author": "The next-gen Kaldi team",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/csukuangfj/sherpa-onnx/issues"
+  },
+  "homepage": "https://github.com/csukuangfj/sherpa-onnx#readme",
+  "optionalDependencies": {
+    "sherpa-onnx-darwin-arm64": "2.0.1",
+    "sherpa-onnx-darwin-x64": "2.0.1",
+    "sherpa-onnx-linux-x64": "2.0.1",
+    "sherpa-onnx-linux-arm64": "2.0.1",
+    "sherpa-onnx-win-x64": "2.0.1",
+    "sherpa-onnx-win-arm64": "2.0.1",
+    "sherpa-onnx-win-ia32": "2.0.1"
+  }
+}

package/node_modules/sherpa-onnx-node/punctuation.js

@@ -0,0 +1,43 @@
+/** @typedef {import('./types').OfflinePunctuationHandle} OfflinePunctuationHandle */
+/** @typedef {import('./types').OfflinePunctuationConfig} OfflinePunctuationConfig */
+/** @typedef {import('./types').OnlinePunctuationConfig} OnlinePunctuationConfig */
+/** @typedef {import('./types').OnlinePunctuationHandle} OnlinePunctuationHandle */
+
+const addon = require('./addon.js');
+
+class OfflinePunctuation {
+  /**
+   * @param {OfflinePunctuationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOfflinePunctuation(config);
+    this.config = config;
+  }
+  /**
+   * Add punctuation to `text` and return the punctuated text.
+   * @param {string} text
+   * @returns {string}
+   */
+  addPunct(text) {
+    return addon.offlinePunctuationAddPunct(this.handle, text);
+  }
+}
+
+class OnlinePunctuation {
+  /**
+   * @param {OnlinePunctuationConfig} config
+   */
+  constructor(config) {
+    this.handle = addon.createOnlinePunctuation(config);
+    this.config = config;
+  }
+  /** @param {string} text @returns {string} */
+  addPunct(text) {
+    return addon.onlinePunctuationAddPunct(this.handle, text);
+  }
+}
+
+module.exports = {
+  OfflinePunctuation,
+  OnlinePunctuation,
+} 

package/node_modules/sherpa-onnx-node/resampler.js

@@ -0,0 +1,80 @@
+/** @typedef {import('./types').LinearResamplerHandle} LinearResamplerHandle */
+
+const addon = require('./addon.js');
+
+/**
+ * A linear resampler that converts audio from one sample rate to another.
+ */
+class LinearResampler {
+  /**
+   * Create a linear resampler.
+   *
+   * @param {number} inputSampleRate - Input sample rate in Hz.
+   * @param {number} outputSampleRate - Output sample rate in Hz.
+   */
+  constructor(inputSampleRate, outputSampleRate) {
+    /** @type {LinearResamplerHandle} */
+    this.handle =
+        addon.createLinearResampler(inputSampleRate, outputSampleRate);
+    this.inputSampleRate = inputSampleRate;
+    this.outputSampleRate = outputSampleRate;
+  }
+
+  /**
+   * Resample a chunk of audio samples.
+   *
+   * Call this for each chunk of input audio. For the final chunk, call
+   * {@link flush} instead so that any internally buffered samples are
+   * emitted.
+   *
+   * @param {Float32Array} samples - Input audio samples.
+   * @returns {Float32Array} Resampled audio samples.
+   */
+  resample(samples) {
+    return addon.resampleLinear(this.handle, samples, 0);
+  }
+
+  /**
+   * Resample the final chunk of audio and flush internal buffers.
+   *
+   * This is the same as {@link resample} but sets flush=1 so that any
+   * remaining samples buffered inside the resampler are emitted. Call
+   * this once after the last chunk of input audio.
+   *
+   * @param {Float32Array} samples - The final chunk of input audio samples.
+   * @returns {Float32Array} Resampled audio samples including buffered tail.
+   */
+  flush(samples) {
+    return addon.resampleLinear(this.handle, samples, 1);
+  }
+
+  /**
+   * Reset the resampler to its initial state, discarding any internal
+   * buffered samples.
+   */
+  reset() {
+    addon.linearResamplerReset(this.handle);
+  }
+
+  /**
+   * Get the input sample rate.
+   *
+   * @returns {number} Input sample rate in Hz.
+   */
+  getInputSampleRate() {
+    return addon.linearResamplerGetInputSampleRate(this.handle);
+  }
+
+  /**
+   * Get the output sample rate.
+   *
+   * @returns {number} Output sample rate in Hz.
+   */
+  getOutputSampleRate() {
+    return addon.linearResamplerGetOutputSampleRate(this.handle);
+  }
+}
+
+module.exports = {
+  LinearResampler,
+}

package/node_modules/sherpa-onnx-node/sherpa-onnx.js

@@ -0,0 +1,49 @@
+/** @typedef {import('./types').WaveObject} WaveObject */
+/**
+ * @typedef {import('./types').OnlineRecognizerResult} OnlineRecognizerResult
+ */
+/**
+ * @typedef {import('./types').OfflineRecognizerResult} OfflineRecognizerResult
+ */
+
+const addon = require('./addon.js')
+const streaming_asr = require('./streaming-asr.js');
+const non_streaming_asr = require('./non-streaming-asr.js');
+const non_streaming_tts = require('./non-streaming-tts.js');
+const vad = require('./vad.js');
+const slid = require('./spoken-language-identification.js');
+const sid = require('./speaker-identification.js');
+const at = require('./audio-tagg.js');
+const punct = require('./punctuation.js');
+const kws = require('./keyword-spotter.js');
+const sd = require('./non-streaming-speaker-diarization.js');
+const speech_denoiser = require('./non-streaming-speech-denoiser.js');
+const online_speech_denoiser = require('./online-speech-denoiser.js');
+const resampler = require('./resampler.js');
+
+module.exports = {
+  OnlineRecognizer : streaming_asr.OnlineRecognizer,
+  OfflineRecognizer : non_streaming_asr.OfflineRecognizer,
+  OfflineTts : non_streaming_tts.OfflineTts,
+  GenerationConfig : non_streaming_tts.GenerationConfig,
+  readWave : addon.readWave,
+  writeWave : addon.writeWave,
+  Display : streaming_asr.Display,
+  Vad : vad.Vad,
+  CircularBuffer : vad.CircularBuffer,
+  SpokenLanguageIdentification : slid.SpokenLanguageIdentification,
+  SpeakerEmbeddingExtractor : sid.SpeakerEmbeddingExtractor,
+  SpeakerEmbeddingManager : sid.SpeakerEmbeddingManager,
+  AudioTagging : at.AudioTagging,
+  OfflinePunctuation : punct.OfflinePunctuation,
+  OnlinePunctuation : punct.OnlinePunctuation,
+  KeywordSpotter : kws.KeywordSpotter,
+  OfflineSpeakerDiarization : sd.OfflineSpeakerDiarization,
+  OfflineSpeechDenoiser : speech_denoiser.OfflineSpeechDenoiser,
+  OnlineSpeechDenoiser : online_speech_denoiser.OnlineSpeechDenoiser,
+  LinearResampler : resampler.LinearResampler,
+  version : addon.version,
+  gitSha1 : addon.gitSha1,
+  gitDate : addon.gitDate,
+  onnxruntimeVersion : addon.onnxruntimeVersion,
+}