parakeet.js 0.0.2 → 0.0.3

package/docs/parakeet-transformers-js/src/parakeet.js

@@ -1,792 +0,0 @@
-// @ts-nocheck
-
-import * as fs from 'fs';
-import * as path from 'path';
-let ort;
-if (isNode()) {
-  // eslint-disable-next-line global-require, import/no-extraneous-dependencies
-  ort = await import('onnxruntime-node');
-  ort = ort.default ?? ort;
-} else {
-  ort = await import('onnxruntime-web').then(m=>m.default ?? m);
-}
-import { logMelSpectrogram, MEL_BINS } from './audio_features.js';
-
-/**
- * Small helper to detect if we are in Node (vs browser).
- */
-function isNode() {
-  return typeof process !== 'undefined' && process.versions?.node;
-}
-
-/**
- * ONNX-based preprocessor for audio feature extraction.
- */
-export class OnnxPreprocessor {
-  constructor(modelPath) {
-    this.modelPath = modelPath;
-    this.session = null;
-  }
-
-  async init() {
-    if (!this.session) {
-      this.session = await ort.InferenceSession.create(this.modelPath);
-    }
-  }
-
-  async process(audio) {
-    if (!this.session) await this.init();
-    
-    // Create a proper Float32Array with explicit ArrayBuffer
-    const buffer = new ArrayBuffer(audio.length * 4); // 4 bytes per float32
-    const audioFloat32 = new Float32Array(buffer);
-    for (let i = 0; i < audio.length; i++) {
-      audioFloat32[i] = audio[i];
-    }
-    
-    // Reshape audio to [1, audio.length] for batch processing
-    const waveforms = new ort.Tensor('float32', audioFloat32, [1, audioFloat32.length]);
-    
-    // Create proper BigInt64Array for lengths
-    const lenBuffer = new ArrayBuffer(8); // 8 bytes per int64
-    const lenArray = new BigInt64Array(lenBuffer);
-    lenArray[0] = BigInt(audioFloat32.length);
-    const waveforms_lens = new ort.Tensor('int64', lenArray, [1]);
-    
-    const feeds = {
-      waveforms: waveforms,
-      waveforms_lens: waveforms_lens
-    };
-    
-    const outputs = await this.session.run(feeds);
-    const featuresTensor = outputs['features'];
-    const features_lens = outputs['features_lens'];
-
-    // The preprocessor ONNX model outputs features in [batch, features, time]
-    // format. The python equivalent (onnx-asr) does not transpose here, so we will
-    // match that behavior and return the raw features. The consuming `transcribe`
-    // function will be updated to handle this layout.
-    return {
-      features: featuresTensor.data,
-      length: Number(features_lens.data[0]),
-    };
-  }
-}
-
-/**
- * Load a text file returning its content as string.
- * Works in both Node and browser (using fetch).
- */
-async function loadText(filePath) {
-  if (isNode()) {
-    return fs.promises.readFile(filePath, 'utf8');
-  }
-  const resp = await fetch(filePath);
-  if (!resp.ok) throw new Error(`Failed to fetch ${filePath}: ${resp.status}`);
-  return resp.text();
-}
-
-/**
- * Basic tokenizer that only supports decoding (id -> text).
- * `tokens.txt` format: one token per line: "token id".
- */
-export class ParakeetTokenizer {
-  /**
-   * @param {string[]} id2token Array where index=id, value=token string
-   */
-  constructor(id2token) {
-    this.id2token = id2token;
-    this.blankToken = '<blk>';
-  }
-
-  static async fromTokensFile(tokensPath) {
-    const content = await loadText(tokensPath);
-    const lines = content.split(/\r?\n/).filter(Boolean);
-    const id2token = [];
-    for (const line of lines) {
-      const [tok, idStr] = line.split(/\s+/);
-      const id = parseInt(idStr, 10);
-      id2token[id] = tok;
-    }
-    return new ParakeetTokenizer(id2token);
-  }
-
-  /**
-   * Decode an array of token ids to string.
-   * Implements simple SentencePiece-style rule: leading "▁" marks space.
-   */
-  decode(ids) {
-    let text = '';
-    for (const id of ids) {
-      const token = this.id2token[id];
-      if (token === undefined) continue;
-      if (token === this.blankToken) continue;
-      if (token.startsWith('▁')) {
-        // word start
-        text += ' ' + token.slice(1);
-      } else {
-        text += token;
-      }
-    }
-    return text.trim();
-  }
-}
-
-/**
- * Skeleton for Parakeet RNNT model inference.
- */
-export class ParakeetModel {
-  constructor(opts) {
-    this.tokenizer = opts.tokenizer;
-    this.encoderSession = opts.encoderSession;
-    this.decoderSession = opts.decoderSession;
-    this.joinerSession = opts.joinerSession;
-    this.blankId = opts.blankId ?? 1024; // default
-    this.predLayers = opts.predLayers;
-    this.predHidden = opts.predHidden;
-    this._normalizer = opts.normalizer ?? (s=>s);
-    this.modelFormat = opts.modelFormat;
-    this.isCombined = this.modelFormat === 'transformers.js';
-    this.maxTokensPerStep = opts.maxTokensPerStep ?? 10;
-    this.preprocessor = opts.preprocessor; // ONNX preprocessor
-    this.subsampling = opts.subsampling ?? 8;
-    this.windowStride = opts.windowStride ?? 0.01; // Store windowStride
-
-    if (this.isCombined) {
-      // Pre-create zero state tensors expected by combined model
-      const numLayers = this.predLayers ?? 2;
-      const hidden = this.predHidden ?? 640;
-      const size = numLayers * 1 * hidden;
-      const z = new Float32Array(size);
-      this.zeroState1 = new ort.Tensor('float32', z, [numLayers, 1, hidden]);
-      this.zeroState2 = new ort.Tensor('float32', z.slice(), [numLayers, 1, hidden]);
-      this._combState1 = this.zeroState1;
-      this._combState2 = this.zeroState2;
-    }
-
-    // cache for constant inputs that quantised decoder expects
-    this.constInputs = {};
-
-    // Determine joiner input names (encoder & decoder)
-    this.joinerInputs = Object.keys(this.joinerSession.inputMetadata ?? {});
-    if (isNode()) {
-      console.log('[Parakeet] Joiner input names:', this.joinerInputs);
-      console.log('[Parakeet] Encoder inputs:', Object.keys(this.encoderSession.inputMetadata ?? {}));
-      console.log('[Parakeet] Encoder outputs:', Object.keys(this.encoderSession.outputMetadata ?? {}));
-    }
-  }
-
-  static async fromDirectory(baseDir, { ortOptions, preferFloat32 = false } = {}) {
-    const modelFormat = 'transformers.js';
-
-    // Helper to select model path
-    const selectModelPath = (name) => {
-      const floatPath = path.join(baseDir, `${name}.onnx`);
-      const int8Path = path.join(baseDir, `${name}.int8.onnx`);
-
-      if (preferFloat32) {
-        if (fs.existsSync(floatPath)) return floatPath;
-        if (fs.existsSync(int8Path)) {
-          console.warn(`[Parakeet] preferFloat32=true but only found ${int8Path}`);
-          return int8Path;
-        }
-      } else {
-        // Default behavior: prefer int8
-        if (fs.existsSync(int8Path)) return int8Path;
-        if (fs.existsSync(floatPath)) return floatPath;
-      }
-      return null; // Not found
-    };
-
-    const encoderPath = selectModelPath('encoder-model');
-    const decoderJointPath = selectModelPath('decoder_joint-model');
-
-    if (isNode()) {
-      console.log(`[Parakeet] Selected encoder model: ${path.basename(encoderPath)}`);
-      console.log(`[Parakeet] Selected decoder/joiner model: ${path.basename(decoderJointPath)}`);
-    }
-
-    if (!encoderPath || !decoderJointPath) {
-      throw new Error('Model directory must contain encoder/decoder_joint ONNX files.');
-    }
-    
-    // Try vocab.txt first, then tokens.txt
-    let tokensPath = path.join(baseDir, 'vocab.txt');
-    if (!fs.existsSync(tokensPath)) {
-      tokensPath = path.join(baseDir, 'tokens.txt');
-    }
-
-    console.log(`[Parakeet] Loading ${modelFormat} format models from ${baseDir}`);
-    
-    const [tokenizer, encoderSession, joinerSession] = await Promise.all([
-      ParakeetTokenizer.fromTokensFile(tokensPath),
-      ort.InferenceSession.create(encoderPath, ortOptions),
-      ort.InferenceSession.create(decoderJointPath, ortOptions),
-    ]);
-
-    // Load text normalizer rules if present
-    let normalizer = (s)=>s;
-    
-    const normPath = path.join(baseDir, 'normalizer.json');
-    if (fs.existsSync(normPath)) {
-      try {
-        const rules = JSON.parse(await fs.promises.readFile(normPath, 'utf8'));
-        normalizer = (text)=>{
-          let out = text;
-          for (const [pattern, repl] of rules) {
-            out = out.replace(new RegExp(pattern, 'g'), repl);
-          }
-          return out;
-        };
-      } catch(e) { console.warn('[Parakeet] Failed to load normalizer.json', e); }
-    }
-
-    // Extract prediction network metadata (layer & hidden size) if provided by Sherpa-ONNX.
-    let predLayers = 2, predHidden = 640;
-    try {
-      const meta = encoderSession.metadata?.custom_metadata_map ?? {};
-      if (meta.pred_rnn_layers) predLayers = parseInt(meta.pred_rnn_layers, 10);
-      if (meta.pred_hidden) predHidden = parseInt(meta.pred_hidden, 10);
-    } catch (_) { /* ignore */ }
-
-    const configPath = path.join(baseDir, 'config.json');
-    let cfg = {};
-    if (fs.existsSync(configPath)) {
-      try { cfg = JSON.parse(await fs.promises.readFile(configPath,'utf8')); }
-      catch { cfg = {}; }
-    }
-    const maxTokensPerStep = cfg.max_tokens_per_step ?? 10;
-
-    const featureSize = cfg.features_size ?? 128;
-    const subsamplingFactor = cfg.subsampling_factor ?? 8;
-    const windowStride = cfg.window_stride ?? 0.01; // Read from config, default 0.01
-
-    // Create ONNX preprocessor (try nemo128 first, fallback to nemo80)
-    const __filename = new URL(import.meta.url).pathname;
-    const __dirname = path.dirname(__filename);
-    
-    // Get the directory of the current script and find assets
-    let assetsDir = path.join(__dirname, '..', 'assets');
-    let preprocessorPath = path.join(assetsDir, featureSize === 80 ? 'nemo80.onnx' : 'nemo128.onnx');
-    
-    // Fix Windows path issues - remove leading slash on Windows
-    if (process.platform === 'win32' && __dirname.startsWith('/')) {
-      assetsDir = path.join(__dirname.substring(1), '..', 'assets');
-      preprocessorPath = path.join(assetsDir, featureSize === 80 ? 'nemo80.onnx' : 'nemo128.onnx');
-    }
-    
-    if (!fs.existsSync(preprocessorPath)) {
-      // fallback try the other size asset
-      preprocessorPath = path.join(assetsDir, featureSize === 80 ? 'nemo128.onnx' : 'nemo80.onnx');
-    }
-    
-    // Final fallback - try relative to current working directory
-    if (!fs.existsSync(preprocessorPath)) {
-      console.warn('[Parakeet] Preprocessor not found at:', preprocessorPath);
-      preprocessorPath = path.resolve('./assets/nemo128.onnx');
-      if (!fs.existsSync(preprocessorPath)) {
-        preprocessorPath = path.resolve('./assets/nemo80.onnx');
-      }
-    }
-    
-    const preprocessor = new OnnxPreprocessor(preprocessorPath);
-
-    // store subsampling factor for timestamp stride
-    const subsampling = subsamplingFactor;
-
-    return new ParakeetModel({ 
-      tokenizer, 
-      encoderSession, 
-      decoderSession: null,
-      joinerSession,
-      predLayers,
-      predHidden,
-      normalizer,
-      modelFormat,
-      maxTokensPerStep,
-      preprocessor,
-      subsampling,
-      windowStride
-    });
-  }
-
-  /**
-   * Compute 80-dim log-mel spectrogram using ONNX preprocessor.
-   * @param {Float32Array} audio PCM normalized -1..1 @ sampleRate Hz
-   * @param {number} sampleRate
-   * @param {{skipCMVN?:boolean, debug?:boolean}} opts
-   * @returns {Promise<Float32Array>} [T, 80]
-   */
-  async computeFeatures(audio, sampleRate, {skipCMVN=false, debug=false}={}) {
-    if (!this.preprocessor) {
-      throw new Error('ONNX preprocessor not initialized');
-    }
-    
-    const result = await this.preprocessor.process(audio);
-    const features = result.features;
-    const T = result.length;
-    const MEL = MEL_BINS;
-    
-    if (debug && isNode()) {
-      console.log(`[Debug] ONNX preprocessor: ${T} frames x ${MEL} mel bins`);
-      console.log('[Debug] first-frame mel (20 bins):', Array.from(features.slice(0,20)).map(v=>v.toFixed(3)).join(' '));
-    }
-    
-    return features;
-  }
-
-  async _runDecoderStep(token, state) {
-    const prev = new ort.Tensor('int32', new Int32Array([token]), [1, 1]);
-    const decInputs = { targets: prev, target_length: new ort.Tensor('int32', new Int32Array([1]), [1]) };
-    Object.assign(decInputs, state, this.constInputs);
-
-    while (true) {
-      try {
-              const decOut = await this.decoderSession.run(decInputs);
-      // Reshape decoder output to [1, 640, 1] for the joiner
-      const decTensor = decOut['outputs'] ?? Object.values(decOut)[0];
-      const reshapedData = new Float32Array(decTensor.data);
-      const reshapedTensor = new ort.Tensor('float32', reshapedData, [1, this.predHidden ?? 640, 1]);
-
-        const newState = Object.fromEntries(Object.entries(decOut).filter(([k]) => k.startsWith('states')));
-
-        return { dec: reshapedTensor, state: newState };
-      } catch (e) {
-        let handled = false;
-        // Missing input
-        let m = /input '([^']+)' is missing/.exec(e.message);
-        if (m) {
-          const missing = m[1];
-          const meta = this.decoderSession.inputMetadata?.[missing];
-          let dims = meta?.dimensions ?? [1];
-          dims = dims.map(d => (typeof d === 'number' && d > 0) ? d : 1);
-          const size = dims.reduce((a, b) => a * b, 1);
-          const type = meta?.type ?? 'float32';
-          let tensor;
-          switch (type) {
-            case 'int32':
-              tensor = new ort.Tensor('int32', new Int32Array(size), dims);
-              break;
-            case 'int64':
-              tensor = new ort.Tensor('int64', new BigInt64Array(size), dims);
-              break;
-            default:
-              tensor = new ort.Tensor('float32', new Float32Array(size), dims);
-          }
-          this.constInputs[missing] = tensor;
-          decInputs[missing] = tensor;
-          handled = true;
-        }
-
-        // Dimension mismatch (rank ok but specific axes wrong)
-        const dimLines = [...e.message.matchAll(/index:\s*(\d+)\s*Got:\s*\d+\s*Expected:\s*(\d+)/g)];
-        if (dimLines.length > 0) {
-          const nameMatch = /input: ([^ ]+)/.exec(e.message);
-          const tensorName = nameMatch ? nameMatch[1] : null;
-          if (tensorName) {
-            const dimsMap = {};
-            let maxIdx = 0;
-            for (const [, idxStr, expStr] of dimLines) {
-              const idx = parseInt(idxStr, 10);
-              const exp = parseInt(expStr, 10);
-              dimsMap[idx] = exp;
-              if (idx > maxIdx) maxIdx = idx;
-            }
-            const newDims = Array(maxIdx + 1).fill(1);
-            for (const k in dimsMap) newDims[k] = dimsMap[k];
-            const size = newDims.reduce((a, b) => a * b, 1);
-            this.constInputs[tensorName] = new ort.Tensor('float32', new Float32Array(size), newDims);
-            decInputs[tensorName] = this.constInputs[tensorName];
-            handled = true;
-          }
-        }
-
-        // Invalid rank mismatch
-        const rankMatch = /Invalid rank for input:?\s*([^ ]+)\s*Got:\s*(\d+)\s*Expected:\s*(\d+)/.exec(e.message);
-        if (rankMatch) {
-          const tensorName = rankMatch[1];
-          const expectedRank = parseInt(rankMatch[3], 10);
-          const meta = this.decoderSession.inputMetadata?.[tensorName];
-          let dims = meta?.dimensions ?? Array(expectedRank).fill(1);
-          if (dims.length !== expectedRank) {
-            dims = Array.from({ length: expectedRank }, (_, i) => (dims[i] && typeof dims[i] === 'number' && dims[i] > 0) ? dims[i] : 1);
-          } else {
-            dims = dims.map(d => (typeof d === 'number' && d > 0) ? d : 1);
-          }
-          const size = dims.reduce((a, b) => a * b, 1);
-          this.constInputs[tensorName] = new ort.Tensor('float32', new Float32Array(size), dims);
-          decInputs[tensorName] = this.constInputs[tensorName];
-          handled = true;
-        }
-
-        if (!handled) throw e;
-      }
-    }
-  }
-
-  async _runCombinedStep(encTensor, token, currentState = null) {
-    // Always pass a single token, matching Python onnx-asr behavior
-    const singleToken = typeof token === 'number' ? token : this.blankId;
-
-    const targetTensor = new ort.Tensor('int32', new Int32Array([singleToken]), [1, 1]);
-    const lenTensor = new ort.Tensor('int32', new Int32Array([1]), [1]);
-
-    // Use provided state or default internal state
-    const state1 = currentState?.state1 || this._combState1;
-    const state2 = currentState?.state2 || this._combState2;
-
-    const feeds = {
-      encoder_outputs: encTensor,
-      targets: targetTensor,
-      target_length: lenTensor,
-      input_states_1: state1,
-      input_states_2: state2,
-    };
-
-    const out = await this.joinerSession.run(feeds);
-    const logits = out['outputs'];
-
-    // The output tensor shape is [B, 1, 1, D] since we're passing a single token.
-    // We can directly use the logits without slicing.
-    const [_B, _, N, D] = logits.dims;
-    const lastLogits = logits.data.subarray(0, D);
-
-    // Split token logits / duration logits
-    const vocab = this.tokenizer.id2token.length;
-    const tokenLogits = lastLogits.slice(0, vocab);
-    const durLogits = lastLogits.slice(vocab);
-    let step = 0;
-    if (durLogits.length > 0) {
-      let max = -Infinity;
-      for (let i = 0; i < durLogits.length; ++i) if (durLogits[i] > max) { max = durLogits[i]; step = i; }
-      
-      // Debug: Log duration logits to understand the pattern
-      if (isNode() && Math.random() < 0.1) { // Log 10% of the time to avoid spam
-        console.log('[DEBUG] Duration logits:', Array.from(durLogits).map((v, i) => `${i}:${v.toFixed(2)}`).join(' '));
-        console.log('[DEBUG] Duration argmax:', step, 'max_value:', max.toFixed(2));
-      }
-    }
-
-    // Return new state for external management
-    const newState = {
-      state1: out['output_states_1'] || state1,
-      state2: out['output_states_2'] || state2
-    };
-
-    return { tokenLogits, step, newState };
-  }
-
-  /**
-   * Transcribe audio.
-   * @param {Float32Array} audio 16 kHz mono PCM [-1,1]
-   * @param {number} sampleRate input sample rate (must be 16k for now)
-   * @param {{returnTimestamps?:boolean, returnConfidences?:boolean, temperature?:number, skipCMVN?:boolean, debug?:boolean}} opts
-   * @returns {Promise<string|{text:string,tokens:number[],timestamps?:[number,number][],confidences?:number[]}>}
-   */
-  async transcribe(audio, sampleRate = 16000, opts = {}) {
-    const {
-      returnTimestamps = false,
-      returnConfidences = false,
-      temperature = 1.2,
-      debug = false,
-      skipCMVN = false
-    } = opts;
-    // 1. feature extraction
-    console.log(`[Parakeet] Got ${audio.length} audio samples @ ${sampleRate} Hz`);
-    const features = await this.computeFeatures(audio, sampleRate, {skipCMVN,debug});
-    const MEL = MEL_BINS;
-    const T = features.length / MEL;
-    
-    // Debug audio preprocessing
-    if (debug && isNode()) {
-      console.log(`[Parakeet] Audio duration: ${(audio.length / sampleRate).toFixed(2)}s`);
-      console.log(`[Parakeet] Feature dims: ${T} frames x ${MEL} mel bins`);
-      
-      // Find min/max without spread operator to avoid stack overflow
-      let audioMin = audio[0], audioMax = audio[0];
-      for (let i = 1; i < audio.length; i++) {
-        if (audio[i] < audioMin) audioMin = audio[i];
-        if (audio[i] > audioMax) audioMax = audio[i];
-      }
-      let featMin = features[0], featMax = features[0];
-      for (let i = 1; i < features.length; i++) {
-        if (features[i] < featMin) featMin = features[i];
-        if (features[i] > featMax) featMax = features[i];
-      }
-      
-      console.log(`[Parakeet] Audio energy: min=${audioMin.toFixed(3)} max=${audioMax.toFixed(3)}`);
-      console.log(`[Parakeet] Feature range: min=${featMin.toFixed(3)} max=${featMax.toFixed(3)}`);
-    }
-
-    const ids = [];
-    const tokenTimes = [];
-    const tokenConfs = [];
-    const frameConfs = []; // per-frame confidences
-    let overallLogProb = 0;
-    
-    // Track decoder state separately for proper state management
-    let decoderState = null;
-
-    // The entire logic is now simplified to process the full feature set at once,
-    // eliminating the need for chunking.
-
-    // 1. Encode the entire feature set
-    const input = new ort.Tensor('float32', features, [1, MEL, T]);
-    const lenTensor = new ort.Tensor('int64', BigInt64Array.from([BigInt(T)]), [1]);
-    const encOut = await this.encoderSession.run({ 'audio_signal': input, 'length': lenTensor });
-    const enc = encOut['outputs'] ?? Object.values(encOut)[0];
-    if (debug && isNode()) console.log(`[Parakeet] Encoder output dims: ${enc.dims}`);
-    
-    // 2. Transpose encoder output to match onnx-asr: [B, D, T] -> [B, T, D]
-    const [B, D, T_enc] = enc.dims;
-    const transposedEncData = new Float32Array(B * T_enc * D);
-    for (let b = 0; b < B; ++b) {
-      for (let t = 0; t < T_enc; ++t) {
-        for (let d = 0; d < D; ++d) {
-          const srcIdx = b * (D * T_enc) + d * T_enc + t;
-          const destIdx = b * (T_enc * D) + t * D + d;
-          transposedEncData[destIdx] = enc.data[srcIdx];
-        }
-      }
-    }
-    const encTransposed = {
-      data: transposedEncData,
-      dims: [B, T_enc, D],
-    };
-    
-    // 3. Decode the transposed encoder output frame by frame
-    const hiddenSize = encTransposed.dims[2]; // D
-    const seqLen = encTransposed.dims[1];     // T_enc (downsampled time-steps)
-    let t = 0;
-    let emittedTokens = 0;
-
-    while (t < seqLen) {
-      const currFrameIdx = t; // Absolute index in encoder frames
-
-      // Slice encoder output for timestep t.
-      const frameBuf = new Float32Array(hiddenSize);
-      const frameOffset = t * hiddenSize; // Since B=1, offset is t * D
-      for (let i = 0; i < hiddenSize; i++) {
-        frameBuf[i] = encTransposed.data[frameOffset + i];
-      }
-      const encTensor = new ort.Tensor('float32', frameBuf, [1, hiddenSize, 1]);
-
-      let tokenLogitsData, step; let durLogitsArr=null;
-      let newDecoderState = null;
-      if (this.isCombined) {
-        const lastToken = ids.length > 0 ? ids[ids.length - 1] : this.blankId;
-        const res = await this._runCombinedStep(encTensor, lastToken, decoderState);
-        tokenLogitsData = res.tokenLogits;
-        step = res.step;
-        newDecoderState = res.newState;
-      } else {
-        // This block for separate decoder/joiner is preserved but may need review
-        // if still in use.
-        const joinFeeds = {};
-        if (this.joinerInputs.length > 0) {
-          this.joinerInputs.forEach((name, idx) => {
-            if (/enc/i.test(name)) joinFeeds[name] = encTensor;
-            else if (/dec/i.test(name)) joinFeeds[name] = dec;
-            else joinFeeds[name] = idx === 0 ? encTensor : dec;
-          });
-        }
-        joinFeeds['encoder_outputs'] = encTensor;
-        joinFeeds['decoder_outputs'] = dec;
-        const joinOut = await this.joinerSession.run(joinFeeds);
-        const joinTensor = Object.values(joinOut)[0];
-        const vocabSize = this.tokenizer.id2token.length;
-        tokenLogitsData = joinTensor.data.slice(0, vocabSize);
-        durLogitsArr = joinTensor.data.slice(vocabSize);
-        step = 0;
-        if (durLogitsArr.length > 0) {
-          let max=-Infinity; for (let i=0;i<durLogitsArr.length;++i) if (durLogitsArr[i]>max){max=durLogitsArr[i]; step=i;}
-        }
-      }
-
-      const tokenLogits = tokenLogitsData;
-      // Apply temperature scaling
-      const scaled = new Float32Array(tokenLogits.length);
-      for (let i = 0; i < tokenLogits.length; ++i) scaled[i] = tokenLogits[i] / temperature;
-
-      // Argmax token & confidence
-      let max = -Infinity, maxId = 0;
-      for (let i = 0; i < scaled.length; ++i) if (scaled[i] > max) { max = scaled[i]; maxId = i; }
-
-      let confVal = 0;
-      if (returnConfidences) {
-        let sum = 0;
-        const maxLogit = max;
-        for (let i = 0; i < scaled.length; ++i) sum += Math.exp(scaled[i] - maxLogit);
-        confVal = 1 / sum;
-        frameConfs.push(confVal);
-        overallLogProb += Math.log(confVal);
-      }
-
-      // Use onnx-asr algorithm: first process token, then decide advancement
-      if (maxId !== this.blankId) {
-        ids.push(maxId);
-        if (returnTimestamps) {
-          const TIME_STRIDE = this.subsampling * this.windowStride;
-          const durationFrames = step > 0 ? step : 1; // at least 1 frame
-          const start = currFrameIdx * TIME_STRIDE;
-          const end = (currFrameIdx + durationFrames) * TIME_STRIDE;
-          tokenTimes.push([start,end]);
-        }
-        if (returnConfidences) tokenConfs.push(confVal);
-
-        if (!this.isCombined) {
-          ({dec, state: newState} = await this._runDecoderStep(maxId,state));
-          state = newState;
-        } else {
-          decoderState = newDecoderState;
-        }
-        emittedTokens += 1;
-      }
-
-      // Now decide advancement based on onnx-asr algorithm
-      const shouldAdvance = maxId === this.blankId || emittedTokens >= this.maxTokensPerStep;
-
-      if (step > 0) {
-        t += step;
-        emittedTokens = 0;
-      } else if (shouldAdvance) {
-        t += 1;
-        emittedTokens = 0;
-      }
-    }
-
-    if (debug && isNode()) {
-      console.log(`[Parakeet] Processed ${t} feature frames (${T} total)`);
-    }
-
-    const text = this._normalizer(this.tokenizer.decode(ids));
-    
-    if (!returnTimestamps && !returnConfidences) {
-        return { utterance_text: text, words: [], metrics: {}, is_final: true };
-    }
-
-    const words = [];
-    let avgWordConfidence = 0;
-    // Prepare arrays for per-token information regardless of timestamp/confidence flags so that
-    // they are in scope for the final return object.
-    const tokensDetailed = [];
-    let avgTokenConfidence = 0;
-
-    if (returnTimestamps) {
-        let currentWord = '';
-        let wordStartTime = 0;
-        let wordEndTime = 0;
-        let wordConfidences = [];
-
-        ids.forEach((tokenId, i) => {
-            const tokenText = this.tokenizer.id2token[tokenId];
-            if (tokenText === this.tokenizer.blankToken) return;
-
-            const tokenTime = tokenTimes[i];
-            const tokenConf = returnConfidences ? tokenConfs[i] : 0;
-            
-            // SentencePiece uses a special character '\u2581' (visible as "▁") to mark the
-            // beginning of a new word. Detect this character instead of a normal space.
-            const isWordStart = tokenText.startsWith('▁');
-
-            if (isWordStart) {
-                // A new word is starting. First, push the old one if it exists.
-                if (currentWord) {
-                    const avgConfidence = wordConfidences.length > 0 ? wordConfidences.reduce((a, b) => a + b, 0) / wordConfidences.length : 0;
-                    words.push({ 
-                        text: currentWord, 
-                        start_time: Number(wordStartTime.toFixed(3)), 
-                        end_time: Number(wordEndTime.toFixed(3)), 
-                        confidence: Number(avgConfidence.toFixed(4))
-                    });
-                }
-                
-                // Now, start the new word
-                currentWord = tokenText.slice(1);
-                wordStartTime = tokenTime[0];
-                wordEndTime = tokenTime[1];
-                wordConfidences = [tokenConf];
-
-            } else {
-                // Not a word start, so it's a continuation of the current word.
-                // This also handles the very first token if it has no leading space.
-                if (!currentWord) {
-                    wordStartTime = tokenTime[0];
-                }
-                currentWord += tokenText;
-                wordEndTime = tokenTime[1]; // just update the end time
-                if (returnConfidences) {
-                    wordConfidences.push(tokenConf);
-                }
-            }
-        });
-
-        // Add the very last word after the loop finishes
-        if (currentWord) {
-            const avgConfidence = wordConfidences.length > 0 ? wordConfidences.reduce((a, b) => a + b, 0) / wordConfidences.length : 0;
-            words.push({ 
-                text: currentWord, 
-                start_time: Number(wordStartTime.toFixed(3)), 
-                end_time: Number(wordEndTime.toFixed(3)),
-                confidence: Number(avgConfidence.toFixed(4))
-            });
-        }
-        
-        if (words.length > 0) {
-            avgWordConfidence = words.map(w => w.confidence).reduce((a,b) => a + b, 0) / words.length;
-        }
-
-        // ------------------------------------------------------------------
-        // Build per-token information array similar to NeMo output structure
-        // ------------------------------------------------------------------
-        ids.forEach((tokenId, i) => {
-            const rawToken = this.tokenizer.id2token[tokenId];
-            if (rawToken === this.tokenizer.blankToken) return; // skip blanks
-
-            const cleanToken = rawToken.startsWith('▁') ? rawToken.slice(1) : rawToken;
-
-            const tokEntry = { token: [cleanToken] };
-
-            if (returnTimestamps && tokenTimes[i]) {
-                const [s, e] = tokenTimes[i];
-                tokEntry.start_time = Number(s.toFixed(3));
-                tokEntry.end_time = Number(e.toFixed(3));
-            }
-
-            if (returnConfidences && tokenConfs[i] !== undefined) {
-                const conf = tokenConfs[i];
-                tokEntry.confidence = Number(conf.toFixed(4));
-            }
-
-            tokensDetailed.push(tokEntry);
-        });
-
-        if (tokensDetailed.length > 0 && returnConfidences) {
-            avgTokenConfidence = tokensDetailed.map(t => t.confidence || 0).reduce((a, b) => a + b, 0) / tokensDetailed.length;
-        }
-    }
-
-    return {
-        utterance_text: text,
-        words,
-        tokens: tokensDetailed,
-        confidence_scores: {
-            ...(returnConfidences ? {
-                token: tokenConfs.map(c=>Number(c.toFixed(4))),
-                token_avg: Number(avgTokenConfidence.toFixed(4)),
-                word: words.map(w=>w.confidence),
-                word_avg: Number(avgWordConfidence.toFixed(4)),
-                frame: frameConfs.map(f=>Number(f.toFixed(4))),
-                frame_avg: frameConfs.length ? Number((frameConfs.reduce((a,b)=>a+b,0)/frameConfs.length).toFixed(4)) : null,
-                overall_log_prob: Number(overallLogProb.toFixed(6))
-            } : {
-                overall_log_prob: null,
-                frame_avg: null,
-                frame: null,
-            }),
-        },
-        is_final: true,
-        ...(debug ? { raw_tokens: ids, raw_token_timestamps: tokenTimes, raw_token_confidences: tokenConfs } : {})
-    };
-  }
-}