speechflow 1.4.5 → 1.5.0

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

@@ -65,18 +65,18 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
                 if (typeof chunk.payload !== "string")
                     throw new Error("chunk payload type must be string")
                 const convertSingle = (
-                    start:      Duration,
-                    end:        Duration,
-                    text:       string,
-                    word?:      string,
-                    occurence?: number
+                    start:       Duration,
+                    end:         Duration,
+                    text:        string,
+                    word?:       string,
+                    occurrence?: number
                 ) => {
                     if (word) {
-                        occurence ??= 1
+                        occurrence ??= 1
                         let match = 1
                         word = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
                         text = text.replaceAll(new RegExp(`\\b${word}\\b`, "g"), (m) => {
-                            if (match++ === occurence)
+                            if (match++ === occurrence)
                                 return `<b>${m}</b>`
                             else
                                 return m
@@ -102,12 +102,12 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
                     output += convertSingle(chunk.timestampStart, chunk.timestampEnd, chunk.payload)
                     const words = (chunk.meta.get("words") ?? []) as
                         { word: string, start: Duration, end: Duration }[]
-                    const occurences = new Map<string, number>()
+                    const occurrences = new Map<string, number>()
                     for (const word of words) {
-                        let occurence = occurences.get(word.word) ?? 0
-                        occurence++
-                        occurences.set(word.word, occurence)
-                        output += convertSingle(word.start, word.end, chunk.payload, word.word, occurence)
+                        let occurrence = occurrences.get(word.word) ?? 0
+                        occurrence++
+                        occurrences.set(word.word, occurrence)
+                        output += convertSingle(word.start, word.end, chunk.payload, word.word, occurrence)
                     }
                 }
                 else
@@ -222,9 +222,8 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
                         }
                     }
                 },
-                handler: (request: HAPI.Request, h: HAPI.ResponseToolkit) => {
-                    return h.response({}).code(204)
-                }
+                handler: (request: HAPI.Request, h: HAPI.ResponseToolkit) =>
+                    h.response({}).code(204)
             })
 
             await this.hapi.start()
@@ -259,7 +258,7 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
         }
     }
 
-    /*  open node  */
+    /*  close node  */
     async close () {
         /*  close stream  */
         if (this.stream !== null) {

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

@@ -46,11 +46,11 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                 "Preserve the original meaning, tone, and nuance.\n" +
                 "Directly translate text from English (EN) to fluent and natural German (DE) language.\n",
             chat: [
-                { role: "user",   content: "I love my wife." },
+                { role: "user",      content: "I love my wife." },
                 { role: "assistant", content: "Ich liebe meine Frau." },
-                { role: "user",   content: "The weather is wonderful." },
+                { role: "user",      content: "The weather is wonderful." },
                 { role: "assistant", content: "Das Wetter ist wunderschön." },
-                { role: "user",   content: "The live is awesome." },
+                { role: "user",      content: "The life is awesome." },
                 { role: "assistant", content: "Das Leben ist einfach großartig." }
             ]
         },
@@ -65,19 +65,19 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                 "Do not chat.\n" +
                 "Do not show any explanations.\n" +
                 "Do not show any introduction.\n" +
-                "Do not show any preamble. \n" +
-                "Do not show any prolog. \n" +
-                "Do not show any epilog. \n" +
+                "Do not show any preamble.\n" +
+                "Do not show any prolog.\n" +
+                "Do not show any epilog.\n" +
                 "Get to the point.\n" +
                 "Preserve the original meaning, tone, and nuance.\n" +
                 "Directly translate text from German (DE) to fluent and natural English (EN) language.\n",
             chat: [
-                { role: "user",   content: "Ich liebe meine Frau." },
+                { role: "user",      content: "Ich liebe meine Frau." },
                 { role: "assistant", content: "I love my wife." },
-                { role: "user",   content: "Das Wetter ist wunderschön." },
+                { role: "user",      content: "Das Wetter ist wunderschön." },
                 { role: "assistant", content: "The weather is wonderful." },
-                { role: "user",   content: "Das Leben ist einfach großartig." },
-                { role: "assistant", content: "The live is awesome." }
+                { role: "user",      content: "Das Leben ist einfach großartig." },
+                { role: "assistant", content: "The life is awesome." }
             ]
         }
     }
@@ -114,7 +114,7 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                 artifact += `:${progress.file}`
             let percent = 0
             if (typeof progress.loaded === "number" && typeof progress.total === "number")
-                percent = (progress.loaded as number / progress.total as number) * 100
+                percent = (progress.loaded / progress.total) * 100
             else if (typeof progress.progress === "number")
                 percent = progress.progress
             if (percent > 0)
@@ -123,7 +123,7 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
         const interval = setInterval(() => {
             for (const [ artifact, percent ] of progressState) {
                 this.log("info", `downloaded ${percent.toFixed(2)}% of artifact "${artifact}"`)
-                if (percent >= 1.0)
+                if (percent >= 100.0)
                     progressState.delete(artifact)
             }
         }, 1000)
@@ -163,9 +163,8 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
         const translate = async (text: string) => {
             if (this.params.model === "OPUS") {
                 const result = await this.translator!(text)
-                return Array.isArray(result) ?
-                    (result[0] as Transformers.TranslationSingle).translation_text :
-                    (result as Transformers.TranslationSingle).translation_text
+                const single = Array.isArray(result) ? result[0] : result
+                return (single as Transformers.TranslationSingle).translation_text
             }
             else if (this.params.model === "SmolLM3") {
                 const key = `SmolLM3:${this.params.src}-${this.params.dst}`
@@ -184,13 +183,11 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                         skip_special_tokens: true
                     })
                 })
-                const generatedText = Array.isArray(result) ?
-                    (result[0] as Transformers.TextGenerationSingle).generated_text :
-                    (result as Transformers.TextGenerationSingle).generated_text
-                const response = typeof generatedText === "string" ?
+                const single = Array.isArray(result) ? result[0] : result
+                const generatedText = (single as Transformers.TextGenerationSingle).generated_text
+                return typeof generatedText === "string" ?
                     generatedText :
                     generatedText.at(-1)!.content
-                return response
             }
             else
                 throw new Error("invalid model")
@@ -205,21 +202,19 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
             transform (chunk: SpeechFlowChunk, encoding, callback) {
                 if (Buffer.isBuffer(chunk.payload))
                     callback(new Error("invalid chunk payload type"))
+                else if (chunk.payload === "") {
+                    this.push(chunk)
+                    callback()
+                }
                 else {
-                    if (chunk.payload === "") {
+                    translate(chunk.payload).then((payload) => {
+                        chunk = chunk.clone()
+                        chunk.payload = payload
                         this.push(chunk)
                         callback()
-                    }
-                    else {
-                        translate(chunk.payload).then((payload) => {
-                            chunk = chunk.clone()
-                            chunk.payload = payload
-                            this.push(chunk)
-                            callback()
-                        }).catch((err) => {
-                            callback(err)
-                        })
-                    }
+                    }).catch((err) => {
+                        callback(err)
+                    })
                 }
             },
             final (callback) {

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

@@ -9,12 +9,16 @@ import Stream from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  SpeechFlow node for data flow filtering (based on meta information)  */
 export default class SpeechFlowNodeFilter extends SpeechFlowNode {
     /*  declare official node name  */
     public static name = "filter"
 
+    /*  cached regular expression instance  */
+    private cachedRegExp = new utils.CachedRegExp()
+
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
         super(id, cfg, opts, args)
@@ -50,33 +54,33 @@ export default class SpeechFlowNodeFilter extends SpeechFlowNode {
                     val2 instanceof RegExp ?
                         val2 :
                         typeof val2 === "string" ?
-                            new RegExp(val2) :
-                            new RegExp(val2.toString()))
+                            this.cachedRegExp.compile(val2) :
+                            this.cachedRegExp.compile(val2.toString()))
+                if (regexp === null) {
+                    /*  fallback to literal string comparison on invalid regex  */
+                    this.log("warning", `invalid regular expression: "${val2}"`)
+                    return (op === "~~" ? (str === val2) : (str !== val2))
+                }
                 return (op === "~~" ? regexp.test(str) : !regexp.test(str))
             }
             else {
                 /*  non-equal comparison  */
-                const coerceNum = (val: any) => {
-                    return typeof val === "number" ? val : (
-                        typeof val === "string" && val.match(/^[\d+-]+$/) ? parseInt(val) : (
+                const coerceNum = (val: any) =>
+                    typeof val === "number" ? val : (
+                        typeof val === "string" && val.match(/^[\d+-]+$/) ? Number.parseInt(val, 10) : (
                             typeof val === "string" && val.match(/^[\d.+-]+$/) ?
-                                parseFloat(val) :
+                                Number.parseFloat(val) :
                                 Number(val)
                         )
                     )
-                }
                 const num1 = coerceNum(val1)
                 const num2 = coerceNum(val2)
                 return (
-                    op === "<" ?
-                        (num1 < num2) :
-                        op === "<=" ?
-                            (num1 <= num2) :
-                            op === ">=" ?
-                                (num1 >= num2) :
-                                op === ">" ?
-                                    (num1 > num2) :
-                                    false
+                    op === "<"  ? (num1 <  num2) :
+                    op === "<=" ? (num1 <= num2) :
+                    op === ">=" ? (num1 >= num2) :
+                    op === ">"  ? (num1 >  num2) :
+                    false
                 )
             }
         }

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

@@ -48,6 +48,23 @@ export default class SpeechFlowNodeTrace extends SpeechFlowNode {
                 this.log(level, msg)
         }
 
+        /*  helper functions for formatting  */
+        const fmtTime = (t: Duration) => t.toFormat("hh:mm:ss.SSS")
+        const fmtMeta = (meta: Map<string, any>) => {
+            if (meta.size === 0)
+                return "none"
+            else
+                return `{ ${Array.from(meta.entries())
+                    .map(([ k, v ]) => `${k}: ${JSON.stringify(v)}`)
+                    .join(", ")
+                } }`
+        }
+        const fmtChunkBase = (chunk: SpeechFlowChunk) =>
+            `chunk: type=${chunk.type} ` +
+            `kind=${chunk.kind} ` +
+            `start=${fmtTime(chunk.timestampStart)} ` +
+            `end=${fmtTime(chunk.timestampEnd)} `
+
         /*  provide Transform stream  */
         const self = this
         this.stream = new Stream.Transform({
@@ -57,22 +74,9 @@ export default class SpeechFlowNodeTrace extends SpeechFlowNode {
             highWaterMark:      1,
             transform (chunk: SpeechFlowChunk, encoding, callback) {
                 let error: Error | undefined
-                const fmtTime = (t: Duration) => t.toFormat("hh:mm:ss.SSS")
-                const fmtMeta = (meta: Map<string, any>) => {
-                    if (meta.size === 0)
-                        return "none"
-                    else
-                        return `{ ${Array.from(meta.entries())
-                            .map(([ k, v ]) => `${k}: ${JSON.stringify(v)}`)
-                            .join(", ")
-                        } }`
-                }
                 if (Buffer.isBuffer(chunk.payload)) {
                     if (self.params.type === "audio")
-                        log("debug", `chunk: type=${chunk.type} ` +
-                            `kind=${chunk.kind} ` +
-                            `start=${fmtTime(chunk.timestampStart)} ` +
-                            `end=${fmtTime(chunk.timestampEnd)} ` +
+                        log("debug", fmtChunkBase(chunk) +
                             `payload-type=Buffer payload-length=${chunk.payload.byteLength} ` +
                             `meta=${fmtMeta(chunk.meta)}`)
                     else
@@ -80,15 +84,12 @@ export default class SpeechFlowNodeTrace extends SpeechFlowNode {
                 }
                 else {
                     if (self.params.type === "text") {
-                        log("debug", `chunk: type=${chunk.type} ` +
-                            `kind=${chunk.kind} ` +
-                            `start=${fmtTime(chunk.timestampStart)} ` +
-                            `end=${fmtTime(chunk.timestampEnd)} ` +
+                        log("debug", fmtChunkBase(chunk) +
                             `payload-type=String payload-length=${chunk.payload.length} ` +
                             `payload-content="${chunk.payload.toString()}" ` +
                             `meta=${fmtMeta(chunk.meta)}`)
                         if (self.params.dashboard !== "")
-                            self.dashboardInfo("text", self.params.dashboard, chunk.kind, chunk.payload.toString())
+                            self.sendDashboard("text", self.params.dashboard, chunk.kind, chunk.payload.toString())
                     }
                     else
                         error = new Error(`${self.params.type} chunk: seen String instead of Buffer chunk type`)

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

@@ -69,17 +69,15 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
         const devices = PortAudio.getDevices()
         for (const device of devices)
             this.log("info", `found audio device "${device.name}" ` +
-                `(inputs: ${device.maxInputChannels}, outputs: ${device.maxOutputChannels}`)
-        const device = devices.find((device) => {
-            return (
-                (   (   mode === "r"   && device.maxInputChannels  > 0)
-                    || (mode === "w"   && device.maxOutputChannels > 0)
-                    || (mode === "rw"  && device.maxInputChannels  > 0 && device.maxOutputChannels > 0)
-                    || (mode === "any" && (device.maxInputChannels > 0 || device.maxOutputChannels > 0)))
-                && device.name.match(name)
-                && device.hostAPIName === api.name
-            )
-        })
+                `(inputs: ${device.maxInputChannels}, outputs: ${device.maxOutputChannels})`)
+        const device = devices.find((device) => (
+            (   (   mode === "r"   && device.maxInputChannels  > 0)
+                || (mode === "w"   && device.maxOutputChannels > 0)
+                || (mode === "rw"  && device.maxInputChannels  > 0 && device.maxOutputChannels > 0)
+                || (mode === "any" && (device.maxInputChannels > 0 || device.maxOutputChannels > 0)))
+            && device.name.match(name)
+            && device.hostAPIName === api.name
+        ))
         if (!device)
             throw new Error(`invalid audio device "${name}" (of audio API type "${type}")`)
         return device
@@ -197,20 +195,14 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
     async close () {
         /*  shutdown PortAudio  */
         if (this.io !== null) {
-            await new Promise<void>((resolve, reject) => {
-                this.io!.abort((err?: Error) => {
-                    if (err)
-                        reject(err)
-                    else
-                        resolve()
+            await new Promise<void>((resolve) => {
+                this.io!.abort(() => {
+                    resolve()
                 })
             })
-            await new Promise<void>((resolve, reject) => {
-                this.io!.quit((err?: Error) => {
-                    if (err)
-                        reject(err)
-                    else
-                        resolve()
+            await new Promise<void>((resolve) => {
+                this.io!.quit(() => {
+                    resolve()
                 })
             })
             this.io = null

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

@@ -23,6 +23,7 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
     /*  internal state  */
     private broker: MQTT.MqttClient | null = null
     private clientId: string = (new UUID(1)).format()
+    private chunkQueue: utils.SingleQueue<SpeechFlowChunk> | null = null
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -63,6 +64,10 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
             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, {
@@ -85,7 +90,7 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
             if (this.params.mode !== "w" && !packet.sessionPresent)
                 this.broker!.subscribe([ this.params.topicRead ], (err) => {
                     if (err)
-                        this.log("error", `failed to subscribe to MQTT topic "${this.params.topicRead}": ${err.message}`)
+                        this.log("warning", `failed to subscribe to MQTT topic "${this.params.topicRead}": ${err.message}`)
                 })
         })
         this.broker.on("reconnect", () => {
@@ -94,49 +99,48 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
         this.broker.on("disconnect", (packet: MQTT.IDisconnectPacket) => {
             this.log("info", `connection closed to MQTT ${this.params.url}`)
         })
-        const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
+        this.chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
         this.broker.on("message", (topic: string, payload: Buffer, packet: MQTT.IPublishPacket) => {
-            if (topic !== this.params.topicRead)
+            if (topic !== this.params.topicRead || this.params.mode === "w")
                 return
             try {
                 const chunk = utils.streamChunkDecode(payload)
-                chunkQueue.write(chunk)
+                this.chunkQueue!.write(chunk)
             }
             catch (_err: any) {
                 this.log("warning", `received invalid CBOR chunk from MQTT ${this.params.url}`)
             }
         })
-        const broker     = this.broker
-        const topicWrite = this.params.topicWrite
-        const type       = this.params.type
-        const mode       = this.params.mode
+        const self = this
         this.stream = new Stream.Duplex({
             writableObjectMode: true,
             readableObjectMode: true,
             decodeStrings:      false,
             highWaterMark:      1,
             write (chunk: SpeechFlowChunk, encoding, callback) {
-                if (mode === "r")
+                if (self.params.mode === "r")
                     callback(new Error("write operation on read-only node"))
-                else if (chunk.type !== type)
-                    callback(new Error(`written chunk is not of ${type} type`))
-                else if (!broker.connected)
+                else if (chunk.type !== self.params.type)
+                    callback(new Error(`written chunk is not of ${self.params.type} type`))
+                else if (!self.broker!.connected)
                     callback(new Error("still no MQTT connection available"))
                 else {
                     const data = Buffer.from(utils.streamChunkEncode(chunk))
-                    broker.publish(topicWrite, data, { qos: 2, retain: false }, (err) => {
+                    self.broker!.publish(self.params.topicWrite, data, { qos: 2, retain: false }, (err) => {
                         if (err)
-                            callback(new Error(`failed to publish to MQTT topic "${topicWrite}": ${err}`))
+                            callback(new Error(`failed to publish to MQTT topic "${self.params.topicWrite}": ${err}`))
                         else
                             callback()
                     })
                 }
             },
             read (size: number) {
-                if (mode === "w")
+                if (self.params.mode === "w")
                     throw new Error("read operation on write-only node")
-                chunkQueue.read().then((chunk) => {
+                self.chunkQueue!.read().then((chunk) => {
                     this.push(chunk, "binary")
+                }).catch((err: Error) => {
+                    self.log("warning", `read on chunk queue operation failed: ${err}`)
                 })
             }
         })
@@ -144,6 +148,9 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
+        /*  clear chunk queue reference  */
+        this.chunkQueue = null
+
         /*  close MQTT broker  */
         if (this.broker !== null) {
             if (this.broker.connected)

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

@@ -66,7 +66,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
             this.server = new ws.WebSocketServer({
                 host: url.hostname,
-                port: Number.parseInt(url.port),
+                port: Number.parseInt(url.port, 10),
                 path: url.pathname
             })
             this.server.on("listening", () => {
@@ -108,18 +108,17 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             this.server.on("error", (error) => {
                 this.log("error", `error of some connection on URL ${this.params.listen}: ${error.message}`)
             })
-            const type = this.params.type
-            const mode = this.params.mode
+            const self = this
             this.stream = new Stream.Duplex({
                 writableObjectMode: true,
                 readableObjectMode: true,
                 decodeStrings:      false,
                 highWaterMark:      1,
                 write (chunk: SpeechFlowChunk, encoding, callback) {
-                    if (mode === "r")
+                    if (self.params.mode === "r")
                         callback(new Error("write operation on read-only node"))
-                    else if (chunk.type !== type)
-                        callback(new Error(`written chunk is not of ${type} type`))
+                    else if (chunk.type !== self.params.type)
+                        callback(new Error(`written chunk is not of ${self.params.type} type`))
                     else if (websockets.size === 0)
                         callback(new Error("still no Websocket connections available"))
                     else {
@@ -137,17 +136,18 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                         }
                         Promise.all(results).then(() => {
                             callback()
-                        }).catch((errors: Error[]) => {
-                            const error = new Error(errors.map((e) => e.message).join("; "))
+                        }).catch((error: Error) => {
                             callback(error)
                         })
                     }
                 },
                 read (size: number) {
-                    if (mode === "w")
+                    if (self.params.mode === "w")
                         throw new Error("read operation on write-only node")
                     chunkQueue.read().then((chunk) => {
                         this.push(chunk, "binary")
+                    }).catch((err: Error) => {
+                        self.log("warning", `read on chunk queue operation failed: ${err}`)
                     })
                 }
             })
@@ -188,33 +188,33 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                 const chunk = utils.streamChunkDecode(buffer)
                 chunkQueue.write(chunk)
             })
-            const client = this.client
-            client.binaryType = "arraybuffer"
-            const type = this.params.type
-            const mode = this.params.mode
+            this.client.binaryType = "arraybuffer"
+            const self = this
             this.stream = new Stream.Duplex({
                 writableObjectMode: true,
                 readableObjectMode: true,
                 decodeStrings:      false,
                 highWaterMark:      1,
                 write (chunk: SpeechFlowChunk, encoding, callback) {
-                    if (mode === "r")
+                    if (self.params.mode === "r")
                         callback(new Error("write operation on read-only node"))
-                    else if (chunk.type !== type)
-                        callback(new Error(`written chunk is not of ${type} type`))
-                    else if (!client.OPEN)
+                    else if (chunk.type !== self.params.type)
+                        callback(new Error(`written chunk is not of ${self.params.type} type`))
+                    else if (!self.client!.OPEN)
                         callback(new Error("still no Websocket connection available"))
                     else {
                         const data = utils.streamChunkEncode(chunk)
-                        client.send(data)
+                        self.client!.send(data)
                         callback()
                     }
                 },
                 read (size: number) {
-                    if (mode === "w")
+                    if (self.params.mode === "w")
                         throw new Error("read operation on write-only node")
                     chunkQueue.read().then((chunk) => {
                         this.push(chunk, "binary")
+                    }).catch((err: Error) => {
+                        self.log("warning", `read on chunk queue operation failed: ${err}`)
                     })
                 }
             })

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

@@ -5,7 +5,7 @@
 */
 
 /*  standard dependencies  */
-import Events from "node:events"
+import Events, { EventEmitter } from "node:events"
 import Stream from "node:stream"
 
 /*  external dependencies  */
@@ -62,6 +62,7 @@ export default class SpeechFlowNode extends Events.EventEmitter {
     timeOpen:       DateTime<boolean> | undefined
     timeZero:       DateTime<boolean> = DateTime.fromMillis(0)
     timeZeroOffset: Duration<boolean> = Duration.fromMillis(0)
+    _accessBus: ((name: string) => EventEmitter) | null = null
 
     /*  the default constructor  */
     constructor (
@@ -87,20 +88,32 @@ export default class SpeechFlowNode extends Events.EventEmitter {
     }
 
     /*  receive external request  */
-    async receiveRequest (args: any[]) {
+    async receiveRequest (args: any[]): Promise<void> {
         /*  no-op  */
     }
 
     /*  send external response  */
-    sendResponse (args: any[]) {
+    sendResponse (args: any[]): void {
         this.emit("send-response", args)
     }
 
-    /*  emit dashboard information  */
-    dashboardInfo (type: "audio", id: string, kind: "final" | "intermediate", value: number): void
-    dashboardInfo (type: "text", id: string, kind: "final" | "intermediate", value: string): void
-    dashboardInfo (type: "audio" | "text", id: string, kind: "final" | "intermediate", value: number | string): void {
-        this.emit("dashboard-info", { type, id, kind, value })
+    /*  receive dashboard information  */
+    async receiveDashboard (type: "audio" | "text", id: string, kind: "final" | "intermediate", value: number | string): Promise<void> {
+        /*  no-op  */
+    }
+
+    /*  send dashboard information  */
+    sendDashboard (type: "audio", id: string, kind: "final" | "intermediate", value: number): void
+    sendDashboard (type: "text", id: string, kind: "final" | "intermediate", value: string): void
+    sendDashboard (type: "audio" | "text", id: string, kind: "final" | "intermediate", value: number | string): void {
+        this.emit("send-dashboard", { type, id, kind, value })
+    }
+
+    /*  access communication bus  */
+    accessBus (name: string): EventEmitter {
+        if (this._accessBus === null)
+            throw new Error("access to communication bus still not possible")
+        return this._accessBus(name)
     }
 
     /*  INTERNAL: utility function: create "params" attribute from constructor of sub-classes  */