speechflow 1.6.4 → 1.6.5

package/speechflow-cli/src/speechflow-node-a2a-expander-wt.ts

@@ -61,34 +61,6 @@ class ExpanderProcessor extends AudioWorkletProcessor {
         return targetOut - levelDB
     }
 
-    /*  update envelope (smoothed amplitude contour) for single channel  */
-    private updateEnvelopeForChannel (
-        chan:           number,
-        samples:        Float32Array,
-        attack:         number,
-        release:        number
-    ): void {
-        /*  fetch old envelope value  */
-        if (this.env[chan] === undefined)
-            this.env[chan] = 1e-12
-        let env = this.env[chan]
-
-        /*  calculate attack/release alpha values  */
-        const alphaA = Math.exp(-1 / (attack  * this.sampleRate))
-        const alphaR = Math.exp(-1 / (release * this.sampleRate))
-
-        /*  iterate over all samples and calculate RMS  */
-        for (const s of samples) {
-            const x = Math.abs(s)
-            const det = x * x
-            if (det > env)
-                env = alphaA * env + (1 - alphaA) * det
-            else
-                env = alphaR * env + (1 - alphaR) * det
-        }
-        this.env[chan] = Math.sqrt(Math.max(env, 1e-12))
-    }
-
     /*  process a single sample frame  */
     process(
         inputs:     Float32Array[][],
@@ -126,7 +98,7 @@ class ExpanderProcessor extends AudioWorkletProcessor {
 
         /*  update envelope per channel  */
         for (let ch = 0; ch < nCh; ch++)
-            this.updateEnvelopeForChannel(ch, input[ch], attackS, releaseS)
+            this.env[ch] = util.updateEnvelopeForChannel(this.env, this.sampleRate, ch, input[ch], attackS, releaseS)
 
         /*  determine linear value from decibel makeup value */
         const makeUpLin = util.dB2lin(makeupDB)

package/speechflow-cli/src/speechflow-node-a2a-ffmpeg.ts

@@ -93,7 +93,7 @@ export default class SpeechFlowNodeA2AFFMPEG extends SpeechFlowNode {
         util.run("starting FFmpeg process", () => this.ffmpeg!.run())
 
         /*  establish a duplex stream and connect it to FFmpeg  */
-        this.stream = Stream.Duplex.from({
+        const ffmpegStream = Stream.Duplex.from({
             writable: streamInput,
             readable: streamOutput
         })
@@ -101,7 +101,7 @@ export default class SpeechFlowNodeA2AFFMPEG extends SpeechFlowNode {
         /*  wrap streams with conversions for chunk vs plain audio  */
         const wrapper1 = util.createTransformStreamForWritableSide()
         const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
-        this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
+        this.stream = Stream.compose(wrapper1, ffmpegStream, wrapper2)
     }
 
     /*  close node  */

package/speechflow-cli/src/speechflow-node-a2a-gender.ts

@@ -5,12 +5,13 @@
 */
 
 /*  standard dependencies  */
-import path               from "node:path"
-import Stream             from "node:stream"
+import path    from "node:path"
+import Stream  from "node:stream"
 
 /*  external dependencies  */
-import * as Transformers  from "@huggingface/transformers"
-import { WaveFile }       from "wavefile"
+import * as Transformers     from "@huggingface/transformers"
+import { WaveFile }          from "wavefile"
+import { getRMS, AudioData } from "audio-inspect"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
@@ -47,7 +48,10 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            window: { type: "number", pos: 0, val: 500 }
+            window:          { type: "number", pos: 0, val: 500  },
+            threshold:       { type: "number", pos: 1, val: 0.50 },
+            hysteresis:      { type: "number", pos: 2, val: 0.25 },
+            volumeThreshold: { type: "number", pos: 3, val: -45  }
         })
 
         /*  declare node input/output format  */
@@ -64,9 +68,6 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
         /*  clear shutdown flag  */
         this.shutdown = false
 
-        /*  pass-through logging  */
-        const log = this.log.bind(this)
-
         /*  the used model  */
         const model = "Xenova/wav2vec2-large-xlsr-53-gender-recognition-librispeech"
 
@@ -102,24 +103,17 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
                 device:    "auto",
                 progress_callback: progressCallback
             })
-            let timeoutId: ReturnType<typeof setTimeout> | null = null
-            const timeoutPromise = new Promise((resolve, reject) => {
-                timeoutId = setTimeout(() =>
-                    reject(new Error("model initialization timeout")), 30 * 1000)
-            })
             this.classifier = await Promise.race([
-                pipelinePromise, timeoutPromise
-            ]).finally(() => {
-                if (timeoutId !== null)
-                    clearTimeout(timeoutId)
-            }) as Transformers.AudioClassificationPipeline
+                pipelinePromise,
+                util.timeoutPromise(30 * 1000, "model initialization timeout")
+            ]) as Transformers.AudioClassificationPipeline
         }
         catch (error) {
             if (this.progressInterval) {
                 clearInterval(this.progressInterval)
                 this.progressInterval = null
             }
-            throw new Error(`failed to initialize classifier pipeline: ${error}`)
+            throw new Error(`failed to initialize classifier pipeline: ${error}`, { cause: error })
         }
         if (this.progressInterval) {
             clearInterval(this.progressInterval)
@@ -128,38 +122,49 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
         if (this.classifier === null)
             throw new Error("failed to instantiate classifier pipeline")
 
+        /*  define sample rate required by model  */
+        const sampleRateTarget = 16000
+
         /*  classify a single large-enough concatenated audio frame  */
         const classify = async (data: Float32Array) => {
             if (this.shutdown || this.classifier === null)
                 throw new Error("classifier shutdown during operation")
-            const classifyPromise = this.classifier(data)
-            let timeoutId: ReturnType<typeof setTimeout> | null = null
-            const timeoutPromise = new Promise((resolve, reject) => {
-                timeoutId = setTimeout(() =>
-                    reject(new Error("classification timeout")), 30 * 1000)
-            })
-            const result = await Promise.race([ classifyPromise, timeoutPromise ]).finally(() => {
-                if (timeoutId !== null)
-                    clearTimeout(timeoutId)
-            }) as Transformers.AudioClassificationOutput | Transformers.AudioClassificationOutput[]
+
+            /*  check volume level and return "unknown" if too low
+                in order to avoid a wrong classificaton  */
+            const audioData = {
+                sampleRate:       sampleRateTarget,
+                numberOfChannels: 1,
+                channelData:      [ data ],
+                duration:         data.length / sampleRateTarget,
+                length:           data.length
+            } satisfies AudioData
+            const rms = getRMS(audioData, { asDB: true })
+            if (rms < this.params.volumeThreshold)
+                return "unknown"
+
+            /*  classify audio  */
+            const result = await Promise.race([
+                this.classifier(data),
+                util.timeoutPromise(30 * 1000, "classification timeout")
+            ]) as Transformers.AudioClassificationOutput | Transformers.AudioClassificationOutput[]
             const classified = Array.isArray(result) ?
                 result as Transformers.AudioClassificationOutput :
                 [ result ]
-            const c1 = classified.find((c: any) => c.label === "male")
-            const c2 = classified.find((c: any) => c.label === "female")
+            const c1 = classified.find((c) => c.label === "male")
+            const c2 = classified.find((c) => c.label === "female")
             const male   = c1 ? c1.score : 0.0
             const female = c2 ? c2.score : 0.0
-            if (male > 0.50 && male > female + 0.25)
+            const threshold  = this.params.threshold
+            const hysteresis = this.params.hysteresis
+            if (male > threshold && male > female + hysteresis)
                 return "male"
-            else if (female > 0.50 && female > male + 0.25)
+            else if (female > threshold && female > male + hysteresis)
                 return "female"
             else
                 return "unknown"
         }
 
-        /*  define sample rate required by model  */
-        const sampleRateTarget = 16000
-
         /*  work off queued audio frames  */
         const frameWindowDuration = this.params.window / 1000
         const frameWindowSamples  = Math.floor(frameWindowDuration * sampleRateTarget)
@@ -209,13 +214,13 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
                         pos0++
                     }
                     if (lastGender !== gender && !this.shutdown) {
-                        log("info", `gender now recognized as <${gender}>`)
+                        this.log("info", `gender now recognized as <${gender}>`)
                         lastGender = gender
                     }
                 }
             }
             catch (error) {
-                log("error", `gender classification error: ${error}`)
+                this.log("error", `gender classification error: ${error}`)
             }
 
             /*  re-initiate working off round  */
@@ -307,7 +312,7 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
                                 && element.gender === undefined)
                                 break
                             const duration = util.audioArrayDuration(element.data)
-                            log("debug", `send chunk (${duration.toFixed(3)}s) with gender <${element.gender}>`)
+                            self.log("debug", `send chunk (${duration.toFixed(3)}s) with gender <${element.gender}>`)
                             element.chunk.meta.set("gender", element.gender)
                             this.push(element.chunk)
                             self.queueSend.walk(+1)

package/speechflow-cli/src/speechflow-node-a2a-meter.ts

@@ -22,7 +22,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
     /*  internal state  */
     private emitInterval: ReturnType<typeof setInterval> | null = null
     private calcInterval: ReturnType<typeof setInterval> | null = null
-    private silenceTimer: ReturnType<typeof setTimeout> | null = null
+    private silenceTimer: ReturnType<typeof setTimeout>  | null = null
     private chunkBuffer = new Float32Array(0)
     private destroyed = false
 
@@ -32,7 +32,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            interval:  { type: "number", pos: 0, val: 250 },
+            interval:  { type: "number", pos: 0, val: 100 },
             mode:      { type: "string", pos: 1, val: "filter", match: /^(?:filter|sink)$/ },
             dashboard: { type: "string",         val: "" }
         })
@@ -55,71 +55,91 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
         this.destroyed = false
 
         /*  internal state  */
-        const sampleWindowDuration = 3 /* LUFS-S requires 3s */
+        let lufsm = -60
+        let rms   = -60
+
+        /*  chunk processing state for LUFS-M  */
+        const sampleWindowDuration = 0.4 /* LUFS-M requires 400ms */
         const sampleWindowSize = Math.floor(this.config.audioSampleRate * sampleWindowDuration)
         const sampleWindow = new Float32Array(sampleWindowSize)
         sampleWindow.fill(0, 0, sampleWindowSize)
-        let lufss = -60
-        let rms   = -60
 
-        /*  chunk processing state  */
+        /*  chunk processing state for RMS  */
         const chunkDuration = 0.050 /* meter update frequency is about 50ms */
         const samplesPerChunk = Math.floor(this.config.audioSampleRate * chunkDuration)
         this.chunkBuffer = new Float32Array(0)
 
-        /*  define chunk processing function  */
-        const processChunk = (chunkData: Float32Array) => {
-            /*  update internal audio sample sliding window  */
-            sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
-            sampleWindow.set(chunkData, sampleWindowSize - chunkData.length)
+        /*  setup chunking interval  */
+        this.calcInterval = setInterval(() => {
+            /*  short-circuit during destruction  */
+            if (this.destroyed)
+                return
 
-            /*  calculate the LUFS-S and RMS metric  */
-            const audioData = {
+            /*  short-circuit if still not enough chunk data  */
+            if (this.chunkBuffer.length < samplesPerChunk)
+                return
+
+            /*  grab the accumulated chunk data  */
+            const chunkData = this.chunkBuffer
+            this.chunkBuffer = new Float32Array(0)
+
+            /*  update internal audio sample sliding window for LUFS-S  */
+            if (chunkData.length > sampleWindow.length)
+                sampleWindow.set(chunkData.subarray(chunkData.length - sampleWindow.length), 0)
+            else {
+                sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
+                sampleWindow.set(chunkData, sampleWindow.length - chunkData.length)
+            }
+
+            /*  calculate the LUFS-M metric  */
+            const audioDataLUFS = {
                 sampleRate:       this.config.audioSampleRate,
                 numberOfChannels: this.config.audioChannels,
                 channelData:      [ sampleWindow ],
                 duration:         sampleWindowDuration,
                 length:           sampleWindow.length
             } satisfies AudioData
-            const lufs = getLUFS(audioData, {
+            const lufs = getLUFS(audioDataLUFS, {
                 channelMode: this.config.audioChannels === 1 ? "mono" : "stereo",
-                calculateShortTerm:     true,
-                calculateMomentary:     false,
+                calculateShortTerm:     false,
+                calculateMomentary:     true,
                 calculateLoudnessRange: false,
                 calculateTruePeak:      false
             })
-            lufss = lufs.shortTerm ? lufs.shortTerm[0] : -60
-            rms = getRMS(audioData, { asDB: true })
+            lufsm = lufs.momentary ? Math.max(-60, lufs.momentary[0]) : -60
+
+            /*  calculate the RMS metric  */
+            const totalSamples   = chunkData.length / this.config.audioChannels
+            const duration       = totalSamples / this.config.audioSampleRate
+            const audioDataRMS = {
+                sampleRate:       this.config.audioSampleRate,
+                numberOfChannels: this.config.audioChannels,
+                channelData:      [ chunkData ],
+                duration,
+                length:           chunkData.length
+            } satisfies AudioData
+            rms = Math.max(-60, getRMS(audioDataRMS, {
+                asDB: true
+            }))
+
+            /*  automatically clear measurement (in case no new measurements happen)  */
             if (this.silenceTimer !== null)
                 clearTimeout(this.silenceTimer)
             this.silenceTimer = setTimeout(() => {
-                lufss = -60
+                lufsm = -60
                 rms   = -60
             }, 500)
-        }
-
-        /*  setup chunking interval  */
-        this.calcInterval = setInterval(() => {
-            if (this.destroyed)
-                return
-
-            /*  process one single 50ms chunk if available  */
-            if (this.chunkBuffer.length >= samplesPerChunk) {
-                const chunkData = this.chunkBuffer.slice(0, samplesPerChunk)
-                this.chunkBuffer = this.chunkBuffer.slice(samplesPerChunk)
-                processChunk(chunkData)
-            }
         }, chunkDuration * 1000)
 
         /*  setup loudness emitting interval  */
         this.emitInterval = setInterval(() => {
             if (this.destroyed)
                 return
-            this.log("debug", `LUFS-S: ${lufss.toFixed(1)} dB, RMS: ${rms.toFixed(1)} dB`)
-            this.sendResponse([ "meter", "LUFS-S", lufss ])
+            this.log("debug", `LUFS-M: ${lufsm.toFixed(1)} dB, RMS: ${rms.toFixed(1)} dB`)
+            this.sendResponse([ "meter", "LUFS-M", lufsm ])
             this.sendResponse([ "meter", "RMS", rms ])
             if (this.params.dashboard !== "")
-                this.sendDashboard("audio", this.params.dashboard, "final", lufss)
+                this.sendDashboard("audio", this.params.dashboard, "final", lufsm)
         }, this.params.interval)
 
         /*  provide Duplex stream and internally attach to meter  */
@@ -175,6 +195,9 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
+        /*  indicate destruction immediately to stop any ongoing operations  */
+        this.destroyed = true
+
         /*  stop intervals  */
         if (this.emitInterval !== null) {
             clearInterval(this.emitInterval)
@@ -194,8 +217,5 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
             this.stream.destroy()
             this.stream = null
         }
-
-        /*  indicate destruction  */
-        this.destroyed = true
     }
 }

package/speechflow-cli/src/speechflow-node-a2a-rnnoise.ts

@@ -44,6 +44,7 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
         this.worker = new Worker(resolve(__dirname, "speechflow-node-a2a-rnnoise-wt.js"))
         this.worker.on("error", (err) => {
             this.log("error", `RNNoise worker thread error: ${err}`)
+            this.stream?.emit("error", err)
         })
         this.worker.on("exit", (code) => {
             if (code !== 0)

package/speechflow-cli/src/speechflow-node-a2a-vad.ts

@@ -158,14 +158,14 @@ export default class SpeechFlowNodeA2AVAD extends SpeechFlowNode {
                         }
                     }
                     catch (error) {
-                        this.log("error", `VAD frame processing error: ${error}`)
+                        this.log("error", `VAD frame processing error: ${error}`, { cause: error })
                     }
                 }
             })
             this.vad.start()
         }
         catch (error) {
-            throw new Error(`failed to initialize VAD: ${error}`)
+            throw new Error(`failed to initialize VAD: ${error}`, { cause: error })
         }
 
         /*  provide Duplex stream and internally attach to VAD  */

package/speechflow-cli/src/speechflow-node-a2t-openai.ts

@@ -23,7 +23,6 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
     public static name = "a2t-openai"
 
     /*  internal state  */
-    private static speexInitialized = false
     private openai:     OpenAI | null = null
     private ws:         ws.WebSocket | null = null
     private queue:      util.SingleQueue<SpeechFlowChunk | null> | null = null
@@ -71,11 +70,6 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
 
         /*  establish resampler from our standard audio sample rate (48Khz)
             to OpenAI's maximum 24Khz input sample rate  */
-        if (!SpeechFlowNodeA2TOpenAI.speexInitialized) {
-            /*  at least once initialize resampler  */
-            await SpeexResampler.initPromise
-            SpeechFlowNodeA2TOpenAI.speexInitialized = true
-        }
         this.resampler = new SpeexResampler(1, this.config.audioSampleRate, 24000, 7)
 
         /*  instantiate OpenAI API  */

package/speechflow-cli/src/speechflow-node-t2a-amazon.ts

@@ -26,7 +26,6 @@ export default class SpeechFlowNodeT2AAmazon extends SpeechFlowNode {
 
     /*  internal state  */
     private client: PollyClient | null = null
-    private static speexInitialized = false
     private destroyed = false
     private resampler: SpeexResampler | null = null
 
@@ -114,11 +113,6 @@ export default class SpeechFlowNodeT2AAmazon extends SpeechFlowNode {
 
         /*  establish resampler from AWS Polly's maximum 16Khz output
             (for PCM output) to our standard audio sample rate (48KHz)  */
-        if (!SpeechFlowNodeT2AAmazon.speexInitialized) {
-            /*  at least once initialize resampler  */
-            await SpeexResampler.initPromise
-            SpeechFlowNodeT2AAmazon.speexInitialized = true
-        }
         this.resampler = new SpeexResampler(1, 16000, this.config.audioSampleRate, 7)
 
         /*  create transform stream and connect it to the AWS Polly API  */

package/speechflow-cli/src/speechflow-node-t2a-elevenlabs.ts

@@ -22,7 +22,6 @@ export default class SpeechFlowNodeT2AElevenlabs extends SpeechFlowNode {
 
     /*  internal state  */
     private elevenlabs: ElevenLabs.ElevenLabsClient | null = null
-    private static speexInitialized = false
     private destroyed = false
     private resampler: SpeexResampler | null = null
 
@@ -131,11 +130,6 @@ export default class SpeechFlowNodeT2AElevenlabs extends SpeechFlowNode {
 
         /*  establish resampler from ElevenLabs's maximum 24Khz
             output to our standard audio sample rate (48KHz)  */
-        if (!SpeechFlowNodeT2AElevenlabs.speexInitialized) {
-            /*  at least once initialize resampler  */
-            await SpeexResampler.initPromise
-            SpeechFlowNodeT2AElevenlabs.speexInitialized = true
-        }
         this.resampler = new SpeexResampler(1, maxSampleRate, this.config.audioSampleRate, 7)
 
         /*  create transform stream and connect it to the ElevenLabs API  */

package/speechflow-cli/src/speechflow-node-t2a-kokoro.ts

@@ -23,7 +23,6 @@ export default class SpeechFlowNodeT2AKokoro extends SpeechFlowNode {
     /*  internal state  */
     private kokoro: KokoroTTS | null = null
     private resampler: SpeexResampler | null = null
-    private static speexInitialized = false
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -82,11 +81,6 @@ export default class SpeechFlowNodeT2AKokoro extends SpeechFlowNode {
 
         /*  establish resampler from Kokoro's maximum 24Khz
             output to our standard audio sample rate (48KHz)  */
-        if (!SpeechFlowNodeT2AKokoro.speexInitialized) {
-            /*  at least once initialize resampler  */
-            SpeechFlowNodeT2AKokoro.speexInitialized = true
-            await SpeexResampler.initPromise
-        }
         this.resampler = new SpeexResampler(1, 24000, this.config.audioSampleRate, 7)
 
         /*  determine voice for text-to-speech operation  */

package/speechflow-cli/src/speechflow-node-t2t-ollama.ts

@@ -177,7 +177,7 @@ export default class SpeechFlowNodeT2TOllama extends SpeechFlowNode {
             models = await this.ollama.list()
         }
         catch (err) {
-            throw new Error(`failed to connect to Ollama API at ${this.params.api}: ${err}`)
+            throw new Error(`failed to connect to Ollama API at ${this.params.api}: ${err}`, { cause: err })
         }
         const exists = models.models.some((m) => m.name === this.params.model)
         if (!exists) {

package/speechflow-cli/src/speechflow-node-t2t-subtitle.ts

@@ -20,13 +20,10 @@ import HAPIWebSocket from "hapi-plugin-websocket"
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
 import * as util                           from "./speechflow-util"
 
-type wsPeerCtx = {
-    peer: string
-}
-type wsPeerInfo = {
-    ctx:        wsPeerCtx
-    ws:         WebSocket
-    req:        http.IncomingMessage
+type WSPeerInfo = {
+    ctx:  Record<string, any>
+    ws:   WebSocket
+    req:  http.IncomingMessage
 }
 
 /*  SpeechFlow node for subtitle (text-to-text) "translations"  */
@@ -160,7 +157,7 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
         }
         else if (this.params.mode === "render") {
             /*  establish REST/WebSocket API  */
-            const wsPeers = new Map<string, wsPeerInfo>()
+            const wsPeers = new Map<string, WSPeerInfo>()
             this.hapi = new HAPI.Server({
                 address: this.params.addr,
                 port:    this.params.port
@@ -205,19 +202,18 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                     plugins: {
                         websocket: {
                             autoping: 30 * 1000,
-                            connect: (args: any) => {
-                                const ctx: wsPeerCtx            = args.ctx
-                                const ws:  WebSocket            = args.ws
-                                const req: http.IncomingMessage = args.req
+                            connect: ({ ctx, ws, req }) => {
                                 const peer = `${req.socket.remoteAddress}:${req.socket.remotePort}`
                                 ctx.peer = peer
                                 wsPeers.set(peer, { ctx, ws, req })
                                 this.log("info", `HAPI: WebSocket: connect: peer ${peer}`)
                             },
-                            disconnect: (args: any) => {
-                                const ctx: wsPeerCtx = args.ctx
+                            disconnect: ({ ctx, ws }) => {
                                 const peer = ctx.peer
                                 wsPeers.delete(peer)
+                                ws.removeAllListeners()
+                                if (ws.readyState === WebSocket.OPEN)
+                                    ws.close()
                                 this.log("info", `HAPI: WebSocket: disconnect: peer ${peer}`)
                             }
                         }

package/speechflow-cli/src/speechflow-node-xio-device.ts

@@ -115,7 +115,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
 
         /*  convert regular stream into object-mode stream  */
         const wrapper1 = util.createTransformStreamForWritableSide()
-        const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
+        const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero, highwaterMark)
         this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
     }
 
@@ -136,7 +136,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         this.stream = this.io as unknown as Stream.Readable
 
         /*  convert regular stream into object-mode stream  */
-        const wrapper = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
+        const wrapper = util.createTransformStreamForReadableSide("audio", () => this.timeZero, highwaterMark)
         this.stream = Stream.compose(this.stream, wrapper)
     }
 
@@ -193,6 +193,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         /*  pass-through PortAudio errors  */
         this.io!.on("error", (err) => {
             this.emit("error", err)
+            this.stream?.emit("error", err)
         })
 
         /*  start PortAudio  */

package/speechflow-cli/src/speechflow-node-xio-websocket.ts

@@ -236,7 +236,7 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
 
         /*  close Websocket client  */
         if (this.client !== null) {
-            this.client!.close()
+            this.client.close()
             this.client = null
         }
 

package/speechflow-cli/src/speechflow-util-audio.ts

@@ -132,6 +132,36 @@ export async function processInt16ArrayInSegments (
     return data
 }
 
+/*  update envelope (smoothed amplitude contour) for single channel  */
+export function updateEnvelopeForChannel(
+    env:            number[],
+    sampleRate:     number,
+    chan:           number,
+    samples:        Float32Array,
+    attack:         number,
+    release:        number
+): number {
+    /*  fetch old envelope value  */
+    if (env[chan] === undefined)
+        env[chan] = 1e-12
+    let currentEnv = env[chan]
+
+    /*  calculate attack/release alpha values  */
+    const alphaA = Math.exp(-1 / (attack  * sampleRate))
+    const alphaR = Math.exp(-1 / (release * sampleRate))
+
+    /*  iterate over all samples and calculate RMS  */
+    for (const s of samples) {
+        const x = Math.abs(s)
+        const det = x * x
+        if (det > currentEnv)
+            currentEnv = alphaA * currentEnv + (1 - alphaA) * det
+        else
+            currentEnv = alphaR * currentEnv + (1 - alphaR) * det
+    }
+    return Math.sqrt(Math.max(currentEnv, 1e-12))
+}
+
 /*  helper functions for linear/decibel conversions  */
 export function lin2dB (x: number): number {
     return 20 * Math.log10(Math.max(x, 1e-12))

package/speechflow-cli/src/speechflow-util-error.ts

@@ -5,8 +5,8 @@
 */
 
 /*  helper function for promise-based timeout  */
-export function timeoutPromise (duration: number = 10 * 1000, info = "timeout") {
-    return new Promise<void>((resolve, reject) => {
+export function timeoutPromise<T = void> (duration: number = 10 * 1000, info = "timeout") {
+    return new Promise<T>((resolve, reject) => {
         setTimeout(() => { reject(new Error(info)) }, duration)
     })
 }
@@ -21,7 +21,13 @@ export function ensureError (error: unknown, prefix?: string, debug = false): Er
         msg = `${prefix}: ${msg}`
     if (debug && error instanceof Error)
         msg = `${msg}\n${error.stack}`
-    return new Error(msg, { cause: error })
+    if (error instanceof Error) {
+        const err = new Error(msg, { cause: error })
+        err.stack = error.stack
+        return err
+    }
+    else
+        return new Error(msg)
 }
 
 /*  helper function for retrieving a Promise object  */