react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp

@@ -0,0 +1,125 @@
+#include <thread>
+
+#include "SpeechToText.h"
+
+namespace rnexecutorch::models::speech_to_text {
+
+using namespace ::executorch::extension;
+using namespace asr;
+using namespace types;
+using namespace stream;
+
+SpeechToText::SpeechToText(const std::string &encoderSource,
+                           const std::string &decoderSource,
+                           const std::string &tokenizerSource,
+                           std::shared_ptr<react::CallInvoker> callInvoker)
+    : callInvoker(std::move(callInvoker)),
+      encoder(std::make_unique<BaseModel>(encoderSource, this->callInvoker)),
+      decoder(std::make_unique<BaseModel>(decoderSource, this->callInvoker)),
+      tokenizer(std::make_unique<TokenizerModule>(tokenizerSource,
+                                                  this->callInvoker)),
+      asr(std::make_unique<ASR>(this->encoder.get(), this->decoder.get(),
+                                this->tokenizer.get())),
+      processor(std::make_unique<OnlineASRProcessor>(this->asr.get())),
+      isStreaming(false), readyToProcess(false) {}
+
+void SpeechToText::unload() noexcept {
+  this->encoder->unload();
+  this->decoder->unload();
+}
+
+std::shared_ptr<OwningArrayBuffer>
+SpeechToText::encode(std::span<float> waveform) const {
+  std::vector<float> encoderOutput = this->asr->encode(waveform);
+  return std::make_shared<OwningArrayBuffer>(encoderOutput);
+}
+
+std::shared_ptr<OwningArrayBuffer>
+SpeechToText::decode(std::span<int32_t> tokens,
+                     std::span<float> encoderOutput) const {
+  std::vector<float> decoderOutput = this->asr->decode(tokens, encoderOutput);
+  return std::make_shared<OwningArrayBuffer>(decoderOutput);
+}
+
+std::vector<char> SpeechToText::transcribe(std::span<float> waveform,
+                                           std::string languageOption) const {
+  std::vector<Segment> segments =
+      this->asr->transcribe(waveform, DecodingOptions(languageOption));
+  std::string transcription;
+
+  size_t transcriptionLength = 0;
+  for (auto &segment : segments) {
+    for (auto &word : segment.words) {
+      transcriptionLength += word.content.size();
+    }
+  }
+  transcription.reserve(transcriptionLength);
+
+  for (auto &segment : segments) {
+    for (auto &word : segment.words) {
+      transcription += word.content;
+    }
+  }
+
+  return {transcription.begin(), transcription.end()};
+}
+
+size_t SpeechToText::getMemoryLowerBound() const noexcept {
+  return this->encoder->getMemoryLowerBound() +
+         this->decoder->getMemoryLowerBound();
+}
+
+void SpeechToText::stream(std::shared_ptr<jsi::Function> callback,
+                          std::string languageOption) {
+  if (this->isStreaming) {
+    throw std::runtime_error("Streaming is already in progress");
+  }
+
+  auto nativeCallback =
+      [this, callback](const std::vector<char> &committedVec,
+                       const std::vector<char> &nonCommittedVec, bool isDone) {
+        this->callInvoker->invokeAsync([callback, committedVec, nonCommittedVec,
+                                        isDone](jsi::Runtime &rt) {
+          callback->call(
+              rt, rnexecutorch::jsi_conversion::getJsiValue(committedVec, rt),
+              rnexecutorch::jsi_conversion::getJsiValue(nonCommittedVec, rt),
+              jsi::Value(isDone));
+        });
+      };
+
+  this->isStreaming = true;
+  while (this->isStreaming) {
+    if (!this->readyToProcess ||
+        this->processor->audioBuffer.size() < SpeechToText::kMinAudioSamples) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+      continue;
+    }
+    ProcessResult res =
+        this->processor->processIter(DecodingOptions(languageOption));
+
+    nativeCallback({res.committed.begin(), res.committed.end()},
+                   {res.nonCommitted.begin(), res.nonCommitted.end()}, false);
+    this->readyToProcess = false;
+  }
+
+  std::string committed = this->processor->finish();
+
+  nativeCallback({committed.begin(), committed.end()}, {}, true);
+
+  this->resetStreamState();
+}
+
+void SpeechToText::streamStop() { this->isStreaming = false; }
+
+void SpeechToText::streamInsert(std::span<float> waveform) {
+  this->processor->insertAudioChunk(waveform);
+  this->readyToProcess = true;
+}
+
+void SpeechToText::resetStreamState() {
+  this->isStreaming = false;
+  this->readyToProcess = false;
+  this->processor = std::make_unique<OnlineASRProcessor>(this->asr.get());
+}
+
+} // namespace rnexecutorch::models::speech_to_text

package/common/rnexecutorch/models/speech_to_text/SpeechToText.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "rnexecutorch/models/speech_to_text/stream/OnlineASRProcessor.h"
+#include <span>
+#include <string>
+#include <vector>
+
+namespace rnexecutorch {
+
+namespace models::speech_to_text {
+
+class SpeechToText {
+public:
+  explicit SpeechToText(const std::string &encoderSource,
+                        const std::string &decoderSource,
+                        const std::string &tokenizerSource,
+                        std::shared_ptr<react::CallInvoker> callInvoker);
+
+  void unload() noexcept;
+  std::shared_ptr<OwningArrayBuffer> encode(std::span<float> waveform) const;
+  std::shared_ptr<OwningArrayBuffer>
+  decode(std::span<int32_t> tokens, std::span<float> encoderOutput) const;
+  std::vector<char> transcribe(std::span<float> waveform,
+                               std::string languageOption) const;
+
+  size_t getMemoryLowerBound() const noexcept;
+
+  // Stream
+  void stream(std::shared_ptr<jsi::Function> callback,
+              std::string languageOption);
+  void streamStop();
+  void streamInsert(std::span<float> waveform);
+
+private:
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  std::unique_ptr<BaseModel> encoder;
+  std::unique_ptr<BaseModel> decoder;
+  std::unique_ptr<TokenizerModule> tokenizer;
+  std::unique_ptr<asr::ASR> asr;
+
+  // Stream
+  std::unique_ptr<stream::OnlineASRProcessor> processor;
+  bool isStreaming;
+  bool readyToProcess;
+
+  constexpr static int32_t kMinAudioSamples = 16000; // 1 second
+
+  void resetStreamState();
+};
+
+} // namespace models::speech_to_text
+
+REGISTER_CONSTRUCTOR(models::speech_to_text::SpeechToText, std::string,
+                     std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+
+} // namespace rnexecutorch

package/common/rnexecutorch/models/speech_to_text/asr/ASR.cpp

@@ -0,0 +1,303 @@
+#include <random>
+#include <sstream>
+
+#include "ASR.h"
+#include "executorch/extension/tensor/tensor_ptr.h"
+#include "rnexecutorch/data_processing/Numerical.h"
+#include "rnexecutorch/data_processing/gzip.h"
+
+namespace rnexecutorch::models::speech_to_text::asr {
+
+using namespace types;
+
+ASR::ASR(const models::BaseModel *encoder, const models::BaseModel *decoder,
+         const TokenizerModule *tokenizer)
+    : encoder(encoder), decoder(decoder), tokenizer(tokenizer),
+      startOfTranscriptionToken(
+          this->tokenizer->tokenToId("<|startoftranscript|>")),
+      endOfTranscriptionToken(this->tokenizer->tokenToId("<|endoftext|>")),
+      timestampBeginToken(this->tokenizer->tokenToId("<|0.00|>")) {}
+
+std::vector<int32_t>
+ASR::getInitialSequence(const DecodingOptions &options) const {
+  std::vector<int32_t> seq;
+  seq.push_back(this->startOfTranscriptionToken);
+
+  if (options.language.has_value()) {
+    int32_t langToken =
+        this->tokenizer->tokenToId("<|" + options.language.value() + "|>");
+    int32_t taskToken = this->tokenizer->tokenToId("<|transcribe|>");
+    seq.push_back(langToken);
+    seq.push_back(taskToken);
+  }
+
+  seq.push_back(this->timestampBeginToken);
+
+  return seq;
+}
+
+GenerationResult ASR::generate(std::span<float> waveform, float temperature,
+                               const DecodingOptions &options) const {
+  std::vector<float> encoderOutput = this->encode(waveform);
+
+  std::vector<int32_t> sequenceIds = this->getInitialSequence(options);
+  const size_t initialSequenceLenght = sequenceIds.size();
+  std::vector<float> scores;
+
+  while (std::cmp_less_equal(sequenceIds.size(), ASR::kMaxDecodeLength)) {
+    std::vector<float> logits = this->decode(sequenceIds, encoderOutput);
+
+    // intentionally comparing float to float
+    // temperatures are predefined, so this is safe
+    if (temperature == 0.0f) {
+      numerical::softmax(logits);
+    } else {
+      numerical::softmaxWithTemperature(logits, temperature);
+    }
+
+    const std::vector<float> &probs = logits;
+
+    int32_t nextId;
+    float nextProb;
+
+    // intentionally comparing float to float
+    // temperatures are predefined, so this is safe
+    if (temperature == 0.0f) {
+      auto maxIt = std::ranges::max_element(probs);
+      nextId = static_cast<int32_t>(std::distance(probs.begin(), maxIt));
+      nextProb = *maxIt;
+    } else {
+      std::discrete_distribution<> dist(probs.begin(), probs.end());
+      std::mt19937 gen((std::random_device{}()));
+      nextId = dist(gen);
+      nextProb = probs[nextId];
+    }
+
+    sequenceIds.push_back(nextId);
+    scores.push_back(nextProb);
+
+    if (nextId == this->endOfTranscriptionToken) {
+      break;
+    }
+  }
+
+  return {.tokens = std::vector<int32_t>(
+              sequenceIds.cbegin() + initialSequenceLenght, sequenceIds.cend()),
+          .scores = scores};
+}
+
+float ASR::getCompressionRatio(const std::string &text) const {
+  size_t compressedSize = gzip::deflateSize(text);
+  return static_cast<float>(text.size()) / static_cast<float>(compressedSize);
+}
+
+std::vector<Segment>
+ASR::generateWithFallback(std::span<float> waveform,
+                          const DecodingOptions &options) const {
+  std::vector<float> temperatures = {0.0f, 0.2f, 0.4f, 0.6f, 0.8f, 1.0f};
+  std::vector<int32_t> bestTokens;
+
+  for (auto t : temperatures) {
+    auto [tokens, scores] = this->generate(waveform, t, options);
+
+    const float cumLogProb = std::transform_reduce(
+        scores.begin(), scores.end(), 0.0f, std::plus<>(),
+        [](float s) { return std::log(std::max(s, 1e-9f)); });
+
+    const float avgLogProb = cumLogProb / static_cast<float>(tokens.size() + 1);
+    const std::string text = this->tokenizer->decode(tokens, true);
+    const float compressionRatio = this->getCompressionRatio(text);
+
+    if (avgLogProb >= -1.0f && compressionRatio < 2.4f) {
+      bestTokens = std::move(tokens);
+      break;
+    }
+  }
+
+  return this->calculateWordLevelTimestamps(bestTokens, waveform);
+}
+
+std::vector<Segment>
+ASR::calculateWordLevelTimestamps(std::span<const int32_t> generatedTokens,
+                                  const std::span<const float> waveform) const {
+  const size_t generatedTokensSize = generatedTokens.size();
+  if (generatedTokensSize < 2 ||
+      generatedTokens[generatedTokensSize - 1] !=
+          this->endOfTranscriptionToken ||
+      generatedTokens[generatedTokensSize - 2] < this->timestampBeginToken) {
+    return {};
+  }
+  std::vector<Segment> segments;
+  std::vector<int32_t> tokens;
+  int32_t prevTimestamp = this->timestampBeginToken;
+
+  for (size_t i = 0; i < generatedTokensSize; i++) {
+    if (generatedTokens[i] < this->timestampBeginToken) {
+      tokens.push_back(generatedTokens[i]);
+    }
+    if (i > 0 && generatedTokens[i - 1] >= this->timestampBeginToken &&
+        generatedTokens[i] >= this->timestampBeginToken) {
+      const int32_t start = prevTimestamp;
+      const int32_t end = generatedTokens[i - 1];
+      auto words = this->estimateWordLevelTimestampsLinear(tokens, start, end);
+      if (words.size()) {
+        segments.emplace_back(std::move(words), 0.0);
+      }
+      tokens.clear();
+      prevTimestamp = generatedTokens[i];
+    }
+  }
+
+  const int32_t start = prevTimestamp;
+  const int32_t end = generatedTokens[generatedTokensSize - 2];
+  auto words = this->estimateWordLevelTimestampsLinear(tokens, start, end);
+
+  if (words.size()) {
+    segments.emplace_back(std::move(words), 0.0);
+  }
+
+  float scalingFactor =
+      static_cast<float>(waveform.size()) /
+      (ASR::kSamplingRate * (end - this->timestampBeginToken) *
+       ASR::kTimePrecision);
+  if (scalingFactor < 1.0f) {
+    for (auto &seg : segments) {
+      for (auto &w : seg.words) {
+        w.start *= scalingFactor;
+        w.end *= scalingFactor;
+      }
+    }
+  }
+
+  return segments;
+}
+
+std::vector<Word>
+ASR::estimateWordLevelTimestampsLinear(std::span<const int32_t> tokens,
+                                       int32_t start, int32_t end) const {
+  const std::vector<int32_t> tokensVec(tokens.begin(), tokens.end());
+  const std::string segmentText = this->tokenizer->decode(tokensVec, true);
+  std::istringstream iss(segmentText);
+  std::vector<std::string> wordsStr;
+  std::string word;
+  while (iss >> word) {
+    wordsStr.emplace_back(" ");
+    wordsStr.back().append(word);
+  }
+
+  size_t numChars = 0;
+  for (const auto &w : wordsStr) {
+    numChars += w.size();
+  }
+  const float duration = (end - start) * ASR::kTimePrecision;
+  const float timePerChar = duration / std::max<float>(1, numChars);
+  const float startOffset = (start - timestampBeginToken) * ASR::kTimePrecision;
+
+  std::vector<Word> wordObjs;
+  wordObjs.reserve(wordsStr.size());
+  int32_t prevCharCount = 0;
+  for (auto &w : wordsStr) {
+    const auto wSize = static_cast<int32_t>(w.size());
+    const float wStart = startOffset + prevCharCount * timePerChar;
+    const float wEnd = wStart + timePerChar * wSize;
+    prevCharCount += wSize;
+    wordObjs.emplace_back(std::move(w), wStart, wEnd);
+  }
+
+  return wordObjs;
+}
+
+std::vector<Segment> ASR::transcribe(std::span<float> waveform,
+                                     const DecodingOptions &options) const {
+  int32_t seek = 0;
+  std::vector<Segment> results;
+
+  while (std::cmp_less(seek * ASR::kSamplingRate, waveform.size())) {
+    int32_t start = seek * ASR::kSamplingRate;
+    const auto end = std::min<int32_t>(
+        (seek + ASR::kChunkSize) * ASR::kSamplingRate, waveform.size());
+    auto chunk = waveform.subspan(start, end - start);
+
+    if (std::cmp_less(chunk.size(), ASR::kMinChunkSamples)) {
+      break;
+    }
+
+    std::vector<Segment> segments = this->generateWithFallback(chunk, options);
+
+    if (segments.empty()) {
+      seek += ASR::kChunkSize;
+      continue;
+    }
+
+    for (auto &seg : segments) {
+      for (auto &w : seg.words) {
+        w.start += seek;
+        w.end += seek;
+      }
+    }
+
+    seek = static_cast<int32_t>(segments.back().words.back().end);
+    results.insert(results.end(), std::make_move_iterator(segments.begin()),
+                   std::make_move_iterator(segments.end()));
+  }
+
+  return results;
+}
+
+std::vector<float> ASR::encode(std::span<float> waveform) const {
+  auto inputShape = {static_cast<int32_t>(waveform.size())};
+
+  const auto modelInputTensor = executorch::extension::make_tensor_ptr(
+      std::move(inputShape), waveform.data(),
+      executorch::runtime::etensor::ScalarType::Float);
+  const auto encoderResult = this->encoder->forward(modelInputTensor);
+
+  if (!encoderResult.ok()) {
+    throw std::runtime_error(
+        "Forward pass failed during encoding, error code: " +
+        std::to_string(static_cast<int32_t>(encoderResult.error())));
+  }
+
+  const auto decoderOutputTensor = encoderResult.get().at(0).toTensor();
+  const auto outputNumel = decoderOutputTensor.numel();
+
+  const float *const dataPtr = decoderOutputTensor.const_data_ptr<float>();
+  return {dataPtr, dataPtr + outputNumel};
+}
+
+std::vector<float> ASR::decode(std::span<int32_t> tokens,
+                               std::span<float> encoderOutput) const {
+  std::vector<int32_t> tokenShape = {1, static_cast<int32_t>(tokens.size())};
+  auto tokensLong = std::vector<int64_t>(tokens.begin(), tokens.end());
+
+  auto tokenTensor = executorch::extension::make_tensor_ptr(
+      tokenShape, tokensLong.data(), ScalarType::Long);
+
+  const auto encoderOutputSize = static_cast<int32_t>(encoderOutput.size());
+  std::vector<int32_t> encShape = {1, ASR::kNumFrames,
+                                   encoderOutputSize / ASR::kNumFrames};
+  auto encoderTensor = executorch::extension::make_tensor_ptr(
+      std::move(encShape), encoderOutput.data(), ScalarType::Float);
+
+  const auto decoderResult =
+      this->decoder->forward({tokenTensor, encoderTensor});
+
+  if (!decoderResult.ok()) {
+    throw std::runtime_error(
+        "Forward pass failed during decoding, error code: " +
+        std::to_string(static_cast<int32_t>(decoderResult.error())));
+  }
+
+  const auto logitsTensor = decoderResult.get().at(0).toTensor();
+  const int32_t outputNumel = logitsTensor.numel();
+
+  const size_t innerDim = logitsTensor.size(1);
+  const size_t dictSize = logitsTensor.size(2);
+
+  const float *const dataPtr =
+      logitsTensor.const_data_ptr<float>() + (innerDim - 1) * dictSize;
+
+  return {dataPtr, dataPtr + outputNumel / innerDim};
+}
+
+} // namespace rnexecutorch::models::speech_to_text::asr

package/common/rnexecutorch/models/speech_to_text/asr/ASR.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "rnexecutorch/TokenizerModule.h"
+#include "rnexecutorch/models/BaseModel.h"
+#include "rnexecutorch/models/speech_to_text/types/DecodingOptions.h"
+#include "rnexecutorch/models/speech_to_text/types/GenerationResult.h"
+#include "rnexecutorch/models/speech_to_text/types/Segment.h"
+
+namespace rnexecutorch::models::speech_to_text::asr {
+
+class ASR {
+public:
+  explicit ASR(const models::BaseModel *encoder,
+               const models::BaseModel *decoder,
+               const TokenizerModule *tokenizer);
+  std::vector<types::Segment>
+  transcribe(std::span<float> waveform,
+             const types::DecodingOptions &options) const;
+  std::vector<float> encode(std::span<float> waveform) const;
+  std::vector<float> decode(std::span<int32_t> tokens,
+                            std::span<float> encoderOutput) const;
+
+private:
+  const models::BaseModel *encoder;
+  const models::BaseModel *decoder;
+  const TokenizerModule *tokenizer;
+
+  int32_t startOfTranscriptionToken;
+  int32_t endOfTranscriptionToken;
+  int32_t timestampBeginToken;
+
+  // Time precision used by Whisper timestamps: each token spans 0.02 seconds
+  constexpr static float kTimePrecision = 0.02f;
+  // The maximum number of tokens the decoder can generate per chunk
+  constexpr static int32_t kMaxDecodeLength = 128;
+  // Maximum duration of each audio chunk to process (in seconds)
+  constexpr static int32_t kChunkSize = 30;
+  // Sampling rate expected by Whisper and the model's audio pipeline (16 kHz)
+  constexpr static int32_t kSamplingRate = 16000;
+  // Minimum allowed chunk length before processing (in audio samples)
+  constexpr static int32_t kMinChunkSamples = 1 * 16000;
+  // Number of mel frames output by the encoder (derived from input spectrogram)
+  constexpr static int32_t kNumFrames = 1500;
+
+  std::vector<int32_t>
+  getInitialSequence(const types::DecodingOptions &options) const;
+  types::GenerationResult generate(std::span<float> waveform, float temperature,
+                                   const types::DecodingOptions &options) const;
+  std::vector<types::Segment>
+  generateWithFallback(std::span<float> waveform,
+                       const types::DecodingOptions &options) const;
+  std::vector<types::Segment>
+  calculateWordLevelTimestamps(std::span<const int32_t> tokens,
+                               std::span<const float> waveform) const;
+  std::vector<types::Word>
+  estimateWordLevelTimestampsLinear(std::span<const int32_t> tokens,
+                                    int32_t start, int32_t end) const;
+  float getCompressionRatio(const std::string &text) const;
+};
+
+} // namespace rnexecutorch::models::speech_to_text::asr

package/common/rnexecutorch/models/speech_to_text/stream/HypothesisBuffer.cpp

@@ -0,0 +1,82 @@
+#include "HypothesisBuffer.h"
+
+namespace rnexecutorch::models::speech_to_text::stream {
+
+using namespace types;
+
+void HypothesisBuffer::insert(std::span<const Word> newWords, float offset) {
+  this->fresh.clear();
+  for (const auto &word : newWords) {
+    const float newStart = word.start + offset;
+    if (newStart > lastCommittedTime - 0.5f) {
+      this->fresh.emplace_back(word.content, newStart, word.end + offset);
+    }
+  }
+
+  if (!this->fresh.empty() && !this->committedInBuffer.empty()) {
+    const float a = this->fresh.front().start;
+    if (std::fabs(a - lastCommittedTime) < 1.0f) {
+      const size_t cn = this->committedInBuffer.size();
+      const size_t nn = this->fresh.size();
+      const std::size_t maxCheck = std::min<std::size_t>({cn, nn, 5});
+      for (size_t i = 1; i <= maxCheck; i++) {
+        std::string c;
+        for (auto it = this->committedInBuffer.cend() - i;
+             it != this->committedInBuffer.cend(); ++it) {
+          if (!c.empty()) {
+            c += ' ';
+          }
+          c += it->content;
+        }
+
+        std::string tail;
+        auto it = this->fresh.cbegin();
+        for (size_t k = 0; k < i; k++, it++) {
+          if (!tail.empty()) {
+            tail += ' ';
+          }
+          tail += it->content;
+        }
+
+        if (c == tail) {
+          this->fresh.erase(this->fresh.begin(), this->fresh.begin() + i);
+          break;
+        }
+      }
+    }
+  }
+}
+
+std::deque<Word> HypothesisBuffer::flush() {
+  std::deque<Word> commit;
+
+  while (!this->fresh.empty() && !this->buffer.empty()) {
+    if (this->fresh.front().content != this->buffer.front().content) {
+      break;
+    }
+    commit.push_back(this->fresh.front());
+    this->buffer.pop_front();
+    this->fresh.pop_front();
+  }
+
+  if (!commit.empty()) {
+    lastCommittedTime = commit.back().end;
+  }
+
+  this->buffer = std::move(this->fresh);
+  this->fresh.clear();
+  this->committedInBuffer.insert(this->committedInBuffer.end(), commit.begin(),
+                                 commit.end());
+  return commit;
+}
+
+void HypothesisBuffer::popCommitted(float time) {
+  while (!this->committedInBuffer.empty() &&
+         this->committedInBuffer.front().end <= time) {
+    this->committedInBuffer.pop_front();
+  }
+}
+
+std::deque<Word> HypothesisBuffer::complete() const { return this->buffer; }
+
+} // namespace rnexecutorch::models::speech_to_text::stream

package/common/rnexecutorch/models/speech_to_text/stream/HypothesisBuffer.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <deque>
+#include <span>
+
+#include "rnexecutorch/models/speech_to_text/types/Word.h"
+
+namespace rnexecutorch::models::speech_to_text::stream {
+
+class HypothesisBuffer {
+public:
+  void insert(std::span<const types::Word> newWords, float offset);
+  std::deque<types::Word> flush();
+  void popCommitted(float time);
+  std::deque<types::Word> complete() const;
+
+private:
+  float lastCommittedTime = 0.0f;
+
+  std::deque<types::Word> committedInBuffer;
+  std::deque<types::Word> buffer;
+  std::deque<types::Word> fresh;
+};
+
+} // namespace rnexecutorch::models::speech_to_text::stream