speechflow 2.2.1 → 2.3.1

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -35,6 +35,66 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
     private queueRecv  = this.queue.pointerUse("recv")
     private closing    = false
     private workingOffTimer: ReturnType<typeof setTimeout> | null = null
+    private lastChunkTime = 0
+
+    /*  known abbreviations from English and German (lowercased),
+        which should NOT be treated as sentence boundaries  */
+    private static abbreviations = new Set([
+        "prof", "dr", "mr", "mrs", "ms", "jr", "sr", "st",
+        "vs", "etc", "ca", "bzw", "bspw", "usw", "sog", "ggf", "evtl"
+    ])
+
+    /*  find the first valid sentence boundary in text  */
+    private static findSentenceBoundary (text: string): { sentence: string, rest: string } | null {
+        for (let i = 0; i < text.length; i++) {
+            /*  match sentence-ending punctuation (including ellipsis "..." and "…")  */
+            const pm = /^(\.\.\.|\u2026|\.|\?|!)/.exec(text.slice(i, i + 3))
+            if (!pm)
+                continue
+            const firstPunctPos = i
+            i += pm[1].length - 1
+
+            /*  extract the word preceding the punctuation mark  */
+            let j = Math.max(0, firstPunctPos - 1)
+            while (j >= 0) {
+                /*  handle surrogate pairs (for characters outside the BMP)  */
+                if (j > 0 && /[\uDC00-\uDFFF]/.test(text[j])) {
+                    if (!/^\p{L}$/u.test(text[j - 1] + text[j]))
+                        break
+                    j -= 2
+                }
+                else {
+                    if (!/^\p{L}$/u.test(text[j]))
+                        break
+                    j--
+                }
+            }
+            const precedingWord = text.substring(j + 1, firstPunctPos)
+
+            /*  skip abbreviations (only relevant for periods)  */
+            if (pm[1] === ".") {
+                /*  skip single-letter abbreviations (handles "U.S.", "e.g.", "i.e.", etc.)  */
+                if (precedingWord.length === 1 && /^\p{L}$/u.test(precedingWord))
+                    continue
+
+                /*  skip known multi-letter abbreviations (case-insensitive matching)  */
+                if (SpeechFlowNodeT2TSentence.abbreviations.has(precedingWord.toLowerCase()))
+                    continue
+            }
+
+            /*  return what follows the punctuation mark
+                (also skip over optional closing quotes/parentheses/brackets)  */
+            const after = text.substring(i + 1)
+            const m = after.match(/^(["\u201D\u2019)\]]*)\s+([\s\S]+)$/)
+            if (m !== null)
+                return { sentence: text.substring(0, i + 1 + m[1].length), rest: m[2] }
+
+            /*  found a punctuation at end of text (possibly with trailing closing chars and whitespace)  */
+            if (/^["\u201D\u2019)\]]*\s*$/.test(after))
+                return { sentence: text.substring(0, i + 1) + after.replace(/\s+$/, ""), rest: "" }
+        }
+        return null
+    }
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -53,7 +113,7 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
 
     /*  concatenate two payloads with proper whitespacing  */
     private concatPayload (s1: string, s2: string) {
-        if (!(s1.match(/\s+$/) || s2.match(/^\s+/)))
+        if (!(/\s+$/.test(s1) || /^\s+/.test(s2)))
             return `${s1} ${s2}`
         else
             return `${s1}${s2}`
@@ -64,24 +124,12 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
         /*  clear destruction flag  */
         this.closing = false
 
-        /*  work off queued text frames  */
-        let workingOff = false
-        const workOffQueue = async () => {
-            if (this.closing)
-                return
-
-            /*  control working off round  */
-            if (workingOff)
-                return
-            workingOff = true
-            if (this.workingOffTimer !== null) {
-                clearTimeout(this.workingOffTimer)
-                this.workingOffTimer = null
-            }
-            this.queue.off("write", workOffQueue)
-
-            /*  try to work off one or more chunks  */
-            while (!this.closing) {
+        /*  work off queued text frames (inner processing)  */
+        const workOffQueueInner = (): boolean => {
+            const maxIterations = 50
+            let iterations = 0
+            while (!this.closing && iterations < maxIterations) {
+                iterations++
                 const element = this.queueSplit.peek()
                 if (element === undefined)
                     break
@@ -91,46 +139,49 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                 }
 
                 /*  skip elements already completed  */
-                if (element.type === "text-frame" && element.chunk.kind === "final" && element.complete === true) {
+                if (element.type === "text-frame"
+                    && element.chunk.kind === "final"
+                    && element.complete === true) {
                     this.queueSplit.walk(+1)
                     continue
                 }
 
                 /*  perform sentence splitting on input chunk  */
                 if (element.chunk.kind === "final") {
+                    element.chunk = element.chunk.clone()
                     const chunk = element.chunk
                     const payload = chunk.payload as string
-                    const m = payload.match(/^((?:.|\r?\n)+?[.;?!])(?:\s+((?:.|\r?\n)+)|\s*)$/)
-                    if (m !== null) {
+                    const boundary = SpeechFlowNodeT2TSentence.findSentenceBoundary(payload)
+                    if (boundary !== null) {
                         /*  contains a sentence  */
-                        const [ , sentence, rest ] = m
-                        if (rest !== undefined && rest !== "") {
+                        const { sentence, rest } = boundary
+                        if (rest !== "") {
                             /*  contains more than a sentence  */
                             const chunk2 = chunk.clone()
                             const duration = Duration.fromMillis(
                                 chunk.timestampEnd.minus(chunk.timestampStart).toMillis() *
-                                (sentence.length / payload.length))
+                                (sentence.length / Math.max(payload.length, 1)))
                             chunk2.timestampStart = chunk.timestampStart.plus(duration)
                             chunk.timestampEnd    = chunk2.timestampStart
                             chunk.payload  = sentence
                             chunk2.payload = rest
                             element.complete = true
-                            this.queue.silent(true)
-                            this.queueSplit.touch()
-                            this.queue.silent(false)
+                            this.queue.silently(() => { this.queueSplit.touch() })
                             this.queueSplit.walk(+1)
                             this.queueSplit.insert({ type: "text-frame", chunk: chunk2, complete: false })
                         }
                         else {
                             /*  contains just the sentence  */
                             element.complete = true
-                            this.queue.silent(true)
-                            this.queueSplit.silent(true)
-                            const position = this.queueSplit.position()
-                            this.queueSplit.walk(+1)
-                            this.queue.silent(false)
-                            this.queueSplit.silent(false)
-                            this.queueSplit.touch(position)
+                            const position = this.queue.silently(() =>
+                                this.queueSplit.silently(() => {
+                                    const pos = this.queueSplit.position()
+                                    this.queueSplit.walk(+1)
+                                    return pos
+                                })
+                            )
+                            if (position < this.queue.elements.length)
+                                this.queueSplit.touch(position)
                         }
                     }
                     else {
@@ -151,21 +202,52 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                             }
                             if (element2.chunk.kind === "final") {
                                 /*  merge into following chunk  */
+                                element2.chunk = element2.chunk.clone()
                                 element2.chunk.timestampStart = element.chunk.timestampStart
                                 element2.chunk.payload = this.concatPayload(element.chunk.payload as string,
                                     element2.chunk.payload as string)
 
                                 /*  remove current element and touch now current element  */
-                                this.queue.silent(true)
-                                this.queueSplit.delete()
-                                this.queue.silent(false)
+                                this.queue.silently(() => { this.queueSplit.delete() })
                                 this.queueSplit.touch()
                             }
-                            else
-                                break
+                            else {
+                                /*  following chunk is intermediate (speculative):
+                                    check timeout to flush incomplete sentence fragment  */
+                                if (this.lastChunkTime > 0
+                                    && (Date.now() - this.lastChunkTime) >= (this.params.timeout as number)) {
+                                    element.complete = true
+                                    const position2 = this.queue.silently(() =>
+                                        this.queueSplit.silently(() => {
+                                            const pos = this.queueSplit.position()
+                                            this.queueSplit.walk(+1)
+                                            return pos
+                                        })
+                                    )
+                                    if (position2 < this.queue.elements.length)
+                                        this.queueSplit.touch(position2)
+                                }
+                                else
+                                    break
+                            }
+                        }
+                        else if (this.lastChunkTime > 0
+                            && (Date.now() - this.lastChunkTime) >= (this.params.timeout as number)) {
+                            /*  no following chunk yet, but timeout expired:
+                                flush incomplete sentence fragment  */
+                            element.complete = true
+                            const position = this.queue.silently(() =>
+                                this.queueSplit.silently(() => {
+                                    const pos = this.queueSplit.position()
+                                    this.queueSplit.walk(+1)
+                                    return pos
+                                })
+                            )
+                            if (position < this.queue.elements.length)
+                                this.queueSplit.touch(position)
                         }
                         else {
-                            /*  no following chunk yet  */
+                            /*  no following chunk yet, still within timeout  */
                             break
                         }
                     }
@@ -173,18 +255,48 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                 else
                     break
             }
+            return (!this.closing && iterations >= maxIterations)
+        }
+
+        /*  work off queued text frames (outer processing)  */
+        let workingOff = false
+        const workOffQueue = async () => {
+            if (this.closing)
+                return
+
+            /*  control working off round  */
+            if (workingOff)
+                return
+            workingOff = true
+            if (this.workingOffTimer !== null) {
+                clearTimeout(this.workingOffTimer)
+                this.workingOffTimer = null
+            }
+            this.queue.off("write", workOffQueue)
 
-            /*  re-initiate working off round (if still not destroyed)  */
-            if (!this.closing) {
-                this.workingOffTimer = setTimeout(workOffQueue, 100)
-                this.queue.once("write", workOffQueue)
+            /*  try to work off one or more chunks  */
+            let hasMore = false
+            try {
+                hasMore = workOffQueueInner()
+            }
+            catch (error) {
+                this.log("error", `sentence splitting error: ${error}`)
+            }
+            finally {
+                /*  re-initiate working off round (if still not destroyed)  */
+                workingOff = false
+                if (!this.closing) {
+                    this.workingOffTimer = setTimeout(workOffQueue, hasMore ? 0 : 100)
+                    this.queue.once("write", workOffQueue)
+                }
             }
-            workingOff = false
         }
         this.queue.once("write", workOffQueue)
 
         /*  provide Duplex stream and internally attach to classifier  */
-        let previewed = false
+        let previewedPayload = ""
+        let flushListenerRegistered = false
+        let eofPushed = false
         const self = this
         this.stream = new Stream.Duplex({
             writableObjectMode: true,
@@ -217,8 +329,9 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                             }
                         }
                     }
-                    previewed = false
+                    previewedPayload = ""
                     self.queueRecv.append({ type: "text-frame", chunk, complete: false })
+                    self.lastChunkTime = Date.now()
                     callback()
                 }
             },
@@ -229,6 +342,20 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                     callback()
                     return
                 }
+
+                /*  promote any trailing intermediate chunk to final
+                    (no replacement will ever arrive, so treat it as final)  */
+                const recvPos = self.queueRecv.position()
+                if (recvPos > 0) {
+                    const element = self.queueRecv.peek(recvPos - 1)
+                    if (element
+                        && element.type === "text-frame"
+                        && element.chunk.kind === "intermediate") {
+                        element.chunk = element.chunk.clone()
+                        element.chunk.kind = "final"
+                    }
+                }
+
                 /*  signal end of file  */
                 self.queueRecv.append({ type: "text-eof" })
                 callback()
@@ -236,17 +363,27 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
 
             /*  send text chunk(s) (readable side of stream)  */
             read (_size) {
+                /*  idempotently push EOF to readable side  */
+                const pushNull = () => {
+                    if (eofPushed)
+                        return
+                    eofPushed = true
+                    this.push(null)
+                }
+
                 /*  flush pending text chunks  */
                 const flushPendingChunks = () => {
+                    flushListenerRegistered = false
                     if (self.closing) {
-                        this.push(null)
+                        pushNull()
                         return
                     }
                     const element = self.queueSend.peek()
                     if (element !== undefined
                         && element.type === "text-eof") {
-                        this.push(null)
+                        pushNull()
                         self.queueSend.walk(+1)
+                        self.queue.trim()
                     }
                     else if (element !== undefined
                         && element.type === "text-frame"
@@ -258,7 +395,7 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                             if (nextElement === undefined)
                                 break
                             else if (nextElement.type === "text-eof") {
-                                this.push(null)
+                                pushNull()
                                 self.queueSend.walk(+1)
                                 eofSeen = true
                                 break
@@ -266,20 +403,22 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                             else if (nextElement.type === "text-frame"
                                 && nextElement.complete !== true)
                                 break
-                            self.log("info", `send text 1 (${nextElement.chunk.kind}): ${JSON.stringify(nextElement.chunk.payload)} pos=${self.queueSend.position()}`)
+                            self.log("info", `send text/complete (${nextElement.chunk.kind}): ${JSON.stringify(nextElement.chunk.payload)} pos=${self.queueSend.position()}`)
                             this.push(nextElement.chunk)
                             self.queueSend.walk(+1)
-                            self.queue.trim()
                         }
+                        previewedPayload = ""
+                        self.queue.trim()
 
                         /*  wait for more data (unless end-of-stream was reached)  */
-                        if (!eofSeen && !self.closing)
+                        if (!eofSeen && !self.closing && !flushListenerRegistered) {
+                            flushListenerRegistered = true
                             self.queue.once("write", flushPendingChunks)
+                        }
                     }
                     else if (element !== undefined
                         && element.type === "text-frame"
                         && element.complete === false
-                        && !previewed
                         && self.params.interim === true) {
                         /*  merge together all still queued elements and
                             send this out as an intermediate chunk as preview  */
@@ -293,17 +432,30 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
                                 break
                             previewChunk.payload = self.concatPayload(
                                 previewChunk.payload as string, element2.chunk.payload as string)
+                            previewChunk.timestampEnd = element2.chunk.timestampEnd
+                        }
+
+                        /*  send preview only if payload actually changed  */
+                        if ((previewChunk.payload as string) !== previewedPayload) {
+                            this.push(previewChunk)
+                            self.log("info", `send text/preview (intermediate): ${JSON.stringify(previewChunk.payload)}`)
+                            previewedPayload = previewChunk.payload as string
                         }
-                        this.push(previewChunk)
-                        self.log("info", `send text 2 (intermediate): ${JSON.stringify(previewChunk.payload)}`)
-                        previewed = true
 
                         /*  wait for more data  */
-                        if (!self.closing)
+                        if (!self.closing && !flushListenerRegistered) {
+                            flushListenerRegistered = true
                             self.queue.once("write", flushPendingChunks)
+                        }
                     }
-                    else if (!self.closing)
+                    else if (!self.closing && !flushListenerRegistered) {
+                        flushListenerRegistered = true
                         self.queue.once("write", flushPendingChunks)
+                    }
+                }
+                if (flushListenerRegistered) {
+                    self.queue.removeListener("write", flushPendingChunks)
+                    flushListenerRegistered = false
                 }
                 flushPendingChunks()
             }
@@ -321,8 +473,9 @@ export default class SpeechFlowNodeT2TSentence extends SpeechFlowNode {
             this.workingOffTimer = null
         }
 
-        /*  remove any pending event listeners  */
+        /*  remove any pending event listeners and clear queue  */
         this.queue.removeAllListeners("write")
+        this.queue.clear()
 
         /*  shutdown stream  */
         if (this.stream !== null) {

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -112,6 +112,9 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                 /*  produce SRT/VTT blocks  */
                 let output = convertSingle(timestampStart, timestampEnd, chunk.payload)
                 if (this.params.words) {
+                    if (words.length === 0)
+                        this.log("warning", "word-level subtitle highlighting requested but no word-level timing data available")
+
                     /*  produce additional SRT/VTT blocks with each word highlighted  */
                     const occurrences = new Map<string, number>()
                     for (const word of words) {
@@ -166,7 +169,7 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
         else if (this.params.mode === "import") {
             /*  parse timestamp in SRT format ("HH:MM:SS,mmm") or VTT format ("HH:MM:SS.mmm")  */
             const parseTimestamp = (ts: string): Duration => {
-                const match = ts.match(/^(\d{2}):(\d{2}):(\d{2})[,.](\d{3})$/)
+                const match = ts.match(/^(\d{2,}):(\d{2}):(\d{2})[,.](\d{3})$/)
                 if (!match)
                     throw new Error(`invalid timestamp format: "${ts}"`)
                 const hours        = Number.parseInt(match[1], 10)
@@ -202,7 +205,7 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
 
                     /*  parse timestamp line  */
                     const timeLine  = lines[lineIdx]
-                    const timeMatch = timeLine.match(/^(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})/)
+                    const timeMatch = timeLine.match(/^(\d{2,}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2,}:\d{2}:\d{2},\d{3})/)
                     if (!timeMatch) {
                         this.log("warning", "SRT contains invalid timestamp line")
                         continue
@@ -230,8 +233,8 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                 const blocks = content.trim().split(/\r?\n\r?\n+/)
                 for (const block of blocks) {
                     const lines = block.trim().split(/\r?\n/)
-                    if (lines.length < 1) {
-                        this.log("warning", "VTT block contains fewer than 1 line")
+                    if (lines.length < 2) {
+                        this.log("warning", "VTT block contains fewer than 2 lines")
                         continue
                     }
 
@@ -244,7 +247,7 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
 
                     /*  parse timestamp line  */
                     const timeLine  = lines[lineIdx]
-                    const timeMatch = timeLine.match(/^(\d{2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}\.\d{3})/)
+                    const timeMatch = timeLine.match(/^(\d{2,}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2,}:\d{2}:\d{2}\.\d{3})/)
                     if (!timeMatch) {
                         this.log("warning", "VTT contains invalid timestamp line")
                         continue
@@ -288,25 +291,42 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                     /*  accumulate input  */
                     buffer += chunk.payload
 
-                    /*  parse accumulated input  */
+                    /*  find the last double-newline boundary to separate
+                        complete blocks from a potentially incomplete trailing block  */
+                    const boundary = /\r?\n\r?\n/g
+                    let lastBoundaryEnd = -1
+                    let match: RegExpExecArray | null
+                    while ((match = boundary.exec(buffer)) !== null)
+                        lastBoundaryEnd = match.index + match[0].length
+
+                    /*  if no complete block boundary found, wait for more data  */
+                    if (lastBoundaryEnd < 0) {
+                        callback()
+                        return
+                    }
+
+                    /*  split buffer into complete portion and remainder  */
+                    const complete  = buffer.substring(0, lastBoundaryEnd)
+                    const remainder = buffer.substring(lastBoundaryEnd)
+
+                    /*  parse only the complete portion  */
                     try {
                         /*  parse entries  */
-                        const entries = (self.params.format === "srt" ? parseSRT(buffer) : parseVTT(buffer))
+                        const entries = (self.params.format === "srt" ? parseSRT(complete) : parseVTT(complete))
 
                         /*  emit parsed entries as individual chunks  */
                         for (const entry of entries) {
                             const chunkNew = new SpeechFlowChunk(entry.start, entry.end, "final", "text", entry.text)
                             this.push(chunkNew)
                         }
-
-                        /*  clear buffer after successful parse  */
-                        buffer = ""
-                        callback()
                     }
                     catch (error: unknown) {
-                        buffer = ""
-                        callback(util.ensureError(error))
+                        self.log("warning", `subtitle parse error: ${util.ensureError(error).message}`)
                     }
+
+                    /*  keep only the unparsed remainder in the buffer  */
+                    buffer = remainder
+                    callback()
                 },
                 final (callback) {
                     /*  process any remaining buffer content  */
@@ -402,7 +422,11 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
             const emit = (chunk: SpeechFlowChunk) => {
                 const data = JSON.stringify(chunk)
                 for (const info of wsPeers.values())
-                    info.ws.send(data)
+                    if (info.ws.readyState === WebSocket.OPEN)
+                        info.ws.send(data, (err) => {
+                            if (err)
+                                this.log("warning", `HAPI: WebSocket: subtitle send failed: ${err.message}`)
+                        })
             }
 
             /*  establish writable stream  */

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -103,7 +103,7 @@ export default class SpeechFlowNodeT2TSummary extends SpeechFlowNode {
 
     /*  count sentences in text  */
     private countSentences (text: string): number {
-        const matches = text.match(/[.;?!]/g)
+        const matches = text.match(/[.;?!]+(?:\s|$)/g)
         return matches ? matches.length : 0
     }
 
@@ -186,7 +186,7 @@ export default class SpeechFlowNodeT2TSummary extends SpeechFlowNode {
             },
             final (callback) {
                 /*  generate final summary if there is accumulated text  */
-                if (self.accumulatedText.length > 0 && self.sentencesSinceLastSummary > 0) {
+                if (self.accumulatedText.length > 0) {
                     self.sentencesSinceLastSummary = 0
                     self.log("info", "generating final summary of accumulated text")
                     const textToSummarize = self.accumulatedText

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -47,6 +47,7 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
 
         /*  helper function for comparing two values  */
         const comparison = (val1: any, op: string, val2: any) => {
+            val1 ??= ""
             if (op === "==" || op === "!=") {
                 /*  equal comparison  */
                 const str1 = (typeof val1 === "string" ? val1 : val1.toString())
@@ -73,8 +74,8 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
                 /*  non-equal comparison  */
                 const coerceNum = (val: any) =>
                     typeof val === "number" ? val : (
-                        typeof val === "string" && val.match(/^[\d+-]+$/) ? Number.parseInt(val, 10) : (
-                            typeof val === "string" && val.match(/^[\d.+-]+$/) ?
+                        typeof val === "string" && val.match(/^[+-]?\d+$/) ? Number.parseInt(val, 10) : (
+                            typeof val === "string" && val.match(/^[+-]?(\d+\.?\d*|\d*\.?\d+)$/) ?
                                 Number.parseFloat(val) :
                                 Number(val)
                         )

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */