speechflow 1.6.4 → 1.6.6

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

@@ -30,6 +30,10 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
             chunkt: { type: "number",         val: 65536,   match: (n: number) => n >= 1024 && n <= 131072 }
         })
 
+        /*  sanity check parameters  */
+        if (this.params.path === "")
+            throw new Error("required parameter \"path\" has to be given")
+
         /*  declare node input/output format  */
         if (this.params.mode === "rw") {
             this.input  = this.params.type
@@ -55,10 +59,6 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
         ) / (1000 / this.params.chunka)
         const highWaterMarkText = this.params.chunkt
 
-        /*  sanity check  */
-        if (this.params.path === "")
-            throw new Error("required parameter \"path\" has to be given")
-
         /*  utility function: create a writable stream as chunker that
             writes to process.stdout but properly handles finish events.
             This ensures the writable side of the composed stream below
@@ -195,24 +195,25 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
     async close () {
         /*  shutdown stream  */
         if (this.stream !== null) {
-            await Promise.race([
-                new Promise<void>((resolve, reject) => {
-                    if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex) {
-                        if (this.stream.writableEnded || this.stream.destroyed)
-                            resolve()
-                        else
-                            this.stream.end((err?: Error) => {
+            /*  only destroy non-stdio streams  */
+            if (this.params.path !== "-")
+                await util.destroyStream(this.stream)
+            else {
+                /*  for stdio streams, just end without destroying  */
+                const stream = this.stream
+                if ((stream instanceof Stream.Writable || stream instanceof Stream.Duplex) &&
+                    (!stream.writableEnded && !stream.destroyed)                             ) {
+                    await Promise.race([
+                        new Promise<void>((resolve, reject) => {
+                            stream.end((err?: Error) => {
                                 if (err) reject(err)
                                 else     resolve()
                             })
-                    }
-                    else
-                        resolve()
-                }),
-                new Promise<void>((resolve) => setTimeout(() => resolve(), 5000))
-            ])
-            if (this.params.path !== "-")
-                this.stream.destroy()
+                        }),
+                        util.timeoutPromise(5000)
+                    ])
+                }
+            }
             this.stream = null
         }
     }

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

@@ -40,6 +40,18 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
             type:       { type: "string", pos: 6, val: "text", match: /^(?:audio|text)$/ }
         })
 
+        /*  sanity check parameters  */
+        if (this.params.url === "")
+            throw new Error("required parameter \"url\" has to be given")
+        if ((this.params.mode === "w" || this.params.mode === "rw") && this.params.topicWrite === "")
+            throw new Error("writing to MQTT requires a topicWrite parameter")
+        if ((this.params.mode === "r" || this.params.mode === "rw") && this.params.topicRead === "")
+            throw new Error("reading from MQTT requires a topicRead parameter")
+        if (this.params.username !== "" && this.params.password === "")
+            throw new Error("username provided but password is missing")
+        if (this.params.username === "" && this.params.password !== "")
+            throw new Error("password provided but username is missing")
+
         /*  declare node input/output format  */
         if (this.params.mode === "rw") {
             this.input  = this.params.type
@@ -57,18 +69,6 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
-        /*  logical parameter sanity check  */
-        if (this.params.url === "")
-            throw new Error("required parameter \"url\" has to be given")
-        if ((this.params.mode === "w" || this.params.mode === "rw") && this.params.topicWrite === "")
-            throw new Error("writing to MQTT requires a topicWrite parameter")
-        if ((this.params.mode === "r" || this.params.mode === "rw") && this.params.topicRead === "")
-            throw new Error("reading from MQTT requires a topicRead parameter")
-        if (this.params.username !== "" && this.params.password === "")
-            throw new Error("username provided but password is missing")
-        if (this.params.username === "" && this.params.password !== "")
-            throw new Error("password provided but username is missing")
-
         /*  connect remotely to a MQTT broker  */
         this.broker = MQTT.connect(this.params.url, {
             protocolId:      "MQTT",
@@ -158,9 +158,9 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
             this.broker = null
         }
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
     }

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

@@ -36,6 +36,12 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
             type:    { type: "string", val: "text", match: /^(?:audio|text)$/ }
         })
 
+        /*  sanity check parameters  */
+        if (this.params.listen !== "" && this.params.connect !== "")
+            throw new Error("Websocket node cannot listen and connect at the same time")
+        else if (this.params.listen === "" && this.params.connect === "")
+            throw new Error("Websocket node requires either listen or connect mode")
+
         /*  declare node input/output format  */
         if (this.params.mode === "rw") {
             this.input  = this.params.type
@@ -53,12 +59,6 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
-        /*  sanity check usage  */
-        if (this.params.listen !== "" && this.params.connect !== "")
-            throw new Error("Websocket node cannot listen and connect at the same time")
-        else if (this.params.listen === "" && this.params.connect === "")
-            throw new Error("Websocket node requires either listen or connect mode")
-
         if (this.params.listen !== "") {
             /*  listen locally on a Websocket port  */
             const url = new URL(this.params.listen)
@@ -136,8 +136,8 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
                         }
                         Promise.all(results).then(() => {
                             callback()
-                        }).catch((error: Error) => {
-                            callback(error)
+                        }).catch((error: unknown) => {
+                            callback(util.ensureError(error))
                         })
                     }
                 },
@@ -236,13 +236,13 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
 
         /*  close Websocket client  */
         if (this.client !== null) {
-            this.client!.close()
+            this.client.close()
             this.client = null
         }
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
     }

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

@@ -44,12 +44,12 @@ export default class SpeechFlowNode extends Events.EventEmitter {
 
     /*  general constant configuration (for reference)  */
     config = {
-        audioChannels:     1,                            /* audio mono channel        */
-        audioBitDepth:     16 as (1 | 8 | 16 | 24 | 32), /* audio PCM 16-bit integer  */
-        audioLittleEndian: true,                         /* audio PCM little-endian   */
-        audioSampleRate:   48000,                        /* audio 48kHz sample rate   */
-        textEncoding:      "utf8" as BufferEncoding,     /* UTF-8 text encoding       */
-        cacheDir:          ""                            /* directory for cache files */
+        audioChannels:     1,                            /*  audio mono channel         */
+        audioBitDepth:     16 as (1 | 8 | 16 | 24 | 32), /*  audio PCM 16-bit integer   */
+        audioLittleEndian: true,                         /*  audio PCM little-endian    */
+        audioSampleRate:   48000,                        /*  audio 48kHz sample rate    */
+        textEncoding:      "utf8" as BufferEncoding,     /*  UTF-8 text encoding        */
+        cacheDir:          ""                            /*  directory for cache files  */
     }
 
     /*  announced information  */

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))
@@ -258,7 +288,7 @@ export class WebAudio {
             this.pendingPromises.clear()
         }
         catch (_err) {
-            /* ignored - cleanup during shutdown */
+            /*  ignored -- cleanup during shutdown  */
         }
 
         /*  disconnect nodes  */

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  */

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

@@ -36,12 +36,12 @@ export function createTransformStreamForWritableSide () {
 
 /*  create a Duplex/Transform stream which has
     object-mode on Readable side and buffer/string-mode on Writable side  */
-export function createTransformStreamForReadableSide (type: "text" | "audio", getTimeZero: () => DateTime) {
+export function createTransformStreamForReadableSide (type: "text" | "audio", getTimeZero: () => DateTime, highWaterMark?: number) {
     return new Stream.Transform({
         readableObjectMode: true,
         writableObjectMode: true,
         decodeStrings: false,
-        highWaterMark: (type === "audio" ? 19200 : 65536), /* audio: 400ms @ 48kHz/16bit/mono, text: 64KB */
+        highWaterMark: highWaterMark ?? (type === "audio" ? 19200 /* 400ms */: 65536 /* 64KB */),
         transform (chunk: Buffer | string, encoding, callback) {
             if (chunk === null) {
                 this.push(null)
@@ -88,7 +88,8 @@ type SpeechFlowChunkSerialized = {
     timestampEnd:   number,
     kind:           string,
     type:           string,
-    payload:        Uint8Array
+    payload:        Uint8Array,
+    meta?:          Array<[ string, any ]>
 }
 
 /*  encode/serialize chunk of data  */
@@ -100,13 +101,15 @@ export function streamChunkEncode (chunk: SpeechFlowChunk) {
         const encoder = new TextEncoder()
         payload = encoder.encode(chunk.payload)
     }
-    const data = {
+    const data: SpeechFlowChunkSerialized = {
         timestampStart: chunk.timestampStart.toMillis(),
         timestampEnd:   chunk.timestampEnd.toMillis(),
         kind:           chunk.kind,
         type:           chunk.type,
         payload
-    } satisfies SpeechFlowChunkSerialized
+    }
+    if (chunk.meta.size > 0)
+        data.meta = Array.from(chunk.meta.entries())
     const _data = CBOR.encode(data)
     return _data
 }
@@ -130,7 +133,8 @@ export function streamChunkDecode (_data: Uint8Array) {
         Duration.fromMillis(data.timestampEnd),
         data.kind as "intermediate" | "final",
         data.type as "audio" | "text",
-        payload
+        payload,
+        data.meta ? new Map(data.meta) : undefined
     )
     return chunk
 }
@@ -195,3 +199,24 @@ export class StreamWrapper extends Stream.Transform {
         super._destroy(error, callback)
     }
 }
+
+/*  helper function for destruction of a stream  */
+export async function destroyStream(
+    stream: Stream.Readable | Stream.Writable | Stream.Duplex | Stream.Transform
+) {
+    /*  signal the end for a writable stream  */
+    if ((stream instanceof Stream.Duplex    ||
+         stream instanceof Stream.Transform ||
+         stream instanceof Stream.Writable    ) &&
+        (!stream.writableEnded &&
+         !stream.destroyed       )                )
+        await Promise.race([
+            new Promise<void>((resolve) => {
+                stream.end(() => { resolve() })
+            }),
+            util.timeoutPromise(5000, "stream end timeout")
+        ])
+
+    /*  destroy the stream  */
+    stream.destroy()
+}