speechflow 1.0.0 → 1.2.0

package/src/speechflow-node-a2a-wav.ts

@@ -7,52 +7,69 @@
 /*  standard dependencies  */
 import Stream           from "node:stream"
 
-/*  external dependencies  */
-import wav              from "wav"
-
 /*  internal dependencies  */
-import SpeechFlowNode   from "./speechflow-node"
-import * as utils       from "./speechflow-utils"
-
-/*  utility class for wrapping a custom stream into a regular Transform stream  */
-class StreamWrapper extends Stream.Transform {
-    private foreignStream: any
-    constructor (foreignStream: any, options: Stream.TransformOptions = {}) {
-        options.readableObjectMode = true
-        options.writableObjectMode = true
-        super(options)
-        this.foreignStream = foreignStream
-        this.foreignStream.on("data", (chunk: any) => {
-            this.push(chunk)
-        })
-        this.foreignStream.on("error", (err: Error) => {
-            this.emit("error", err)
-        })
-        this.foreignStream.on("end", () => {
-            this.push(null)
-        })
-    }
-    _transform (chunk: any, encoding: BufferEncoding, callback: Stream.TransformCallback): void {
-        try {
-            const canContinue = this.foreignStream.write(chunk)
-            if (canContinue)
-                callback()
-            else
-                this.foreignStream.once("drain", callback)
-        }
-        catch (err) {
-            callback(err as Error)
-        }
-    }
-    _flush (callback: Stream.TransformCallback): void {
-        try {
-            if (typeof this.foreignStream.end === "function")
-                this.foreignStream.end()
-            callback()
-        }
-        catch (err) {
-            callback(err as Error)
-        }
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+
+/*  write WAV header  */
+const writeWavHeader = (
+    length: number,
+    options?: { audioFormat?: number, channels?: number, sampleRate?: number, bitDepth?: number }
+) => {
+    const audioFormat  = options?.audioFormat ?? 0x001 /* PCM */
+    const channels     = options?.channels    ?? 1     /* mono */
+    const sampleRate   = options?.sampleRate  ?? 44100 /* 44KHz */
+    const bitDepth     = options?.bitDepth    ?? 16    /* 16-Bit */
+
+    const headerLength = 44
+    const dataLength   = length || (4294967295 - 100)
+    const fileSize     = dataLength + headerLength
+    const header       = Buffer.alloc(headerLength)
+
+    const RIFF         = Buffer.alloc(4, "RIFF")
+    const WAVE         = Buffer.alloc(4, "WAVE")
+    const fmt          = Buffer.alloc(4, "fmt ")
+    const data         = Buffer.alloc(4, "data")
+    const byteRate     = (sampleRate * channels * bitDepth) / 8
+    const blockAlign   = (channels * bitDepth) / 8
+
+    let offset = 0
+    RIFF.copy(header, offset);                  offset += RIFF.length
+    header.writeUInt32LE(fileSize - 8, offset); offset += 4
+    WAVE.copy(header, offset);                  offset += WAVE.length
+    fmt.copy(header, offset);                   offset += fmt.length
+    header.writeUInt32LE(16, offset);           offset += 4
+    header.writeUInt16LE(audioFormat, offset);  offset += 2
+    header.writeUInt16LE(channels, offset);     offset += 2
+    header.writeUInt32LE(sampleRate, offset);   offset += 4
+    header.writeUInt32LE(byteRate, offset);     offset += 4
+    header.writeUInt16LE(blockAlign, offset);   offset += 2
+    header.writeUInt16LE(bitDepth, offset);     offset += 2
+    data.copy(header, offset);                  offset += data.length
+    header.writeUInt32LE(dataLength, offset);   offset += 4
+
+    return header
+}
+
+/*  read WAV header  */
+const readWavHeader = (buffer: Buffer) => {
+    let offset = 0
+    const riffHead     = buffer.subarray(offset, offset + 4).toString(); offset += 4
+    const fileSize     = buffer.readUInt32LE(offset);                    offset += 4
+    const waveHead     = buffer.subarray(offset, offset + 4).toString(); offset += 4
+    const fmtHead      = buffer.subarray(offset, offset + 4).toString(); offset += 4
+    const formatLength = buffer.readUInt32LE(offset);                    offset += 4
+    const audioFormat  = buffer.readUInt16LE(offset);                    offset += 2
+    const channels     = buffer.readUInt16LE(offset);                    offset += 2
+    const sampleRate   = buffer.readUInt32LE(offset);                    offset += 4
+    const byteRate     = buffer.readUInt32LE(offset);                    offset += 4
+    const blockAlign   = buffer.readUInt16LE(offset);                    offset += 2
+    const bitDepth     = buffer.readUInt16LE(offset);                    offset += 2
+    const data         = buffer.subarray(offset, offset + 4).toString(); offset += 4
+    const dataLength   = buffer.readUInt32LE(offset);                    offset += 4
+
+    return {
+        riffHead, fileSize, waveHead, fmtHead, formatLength, audioFormat,
+        channels, sampleRate, byteRate, blockAlign, bitDepth, data, dataLength
     }
 }
 
@@ -77,52 +94,72 @@ export default class SpeechFlowNodeWAV extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
-        if (this.params.mode === "encode") {
-            /*  convert raw/PCM to WAV/PCM  */
-            /*  NOTICE: as this is a continuous stream, the resulting WAV header is not 100%
-                conforming to the WAV standard, as it has to use a zero duration information.
-                This cannot be changed in a stream-based processing.  */
-            const writer = new wav.Writer({
-                format:     0x0001 /* PCM */,
-                channels:   this.config.audioChannels,
-                sampleRate: this.config.audioSampleRate,
-                bitDepth:   this.config.audioBitDepth
-            })
-            this.stream = new StreamWrapper(writer)
-        }
-        else if (this.params.mode === "decode") {
-            /*  convert WAV/PCM to raw/PCM  */
-            const reader = new wav.Reader()
-            reader.on("format", (format: any) => {
-                this.log("info", `WAV audio stream: format=${format.audioFormat === 0x0001 ? "PCM" :
-                    "0x" + (format.audioFormat as number).toString(16).padStart(4, "0")} ` +
-                    `bitDepth=${format.bitDepth} ` +
-                    `signed=${format.signed ? "yes" : "no"} ` +
-                    `endian=${format.endianness} ` +
-                    `sampleRate=${format.sampleRate} ` +
-                    `channels=${format.channels}`)
-                if (format.audioFormat !== 0x0001 /* PCM */)
-                    throw new Error("WAV not based on PCM format")
-                if (format.bitDepth !== 16)
-                    throw new Error("WAV not based on 16 bit samples")
-                if (!format.signed)
-                    throw new Error("WAV not based on signed integers")
-                if (format.endianness !== "LE")
-                    throw new Error("WAV not based on little endianness")
-                if (format.sampleRate !== 48000)
-                    throw new Error("WAV not based on 48Khz sample rate")
-                if (format.channels !== 1)
-                    throw new Error("WAV not based on mono channel")
-            })
-            this.stream = new StreamWrapper(reader)
-        }
-        else
-            throw new Error(`invalid operation mode "${this.params.mode}"`)
-
-        /*  convert regular stream into object-mode stream  */
-        const wrapper1 = utils.createTransformStreamForWritableSide()
-        const wrapper2 = utils.createTransformStreamForReadableSide("audio", () => this.timeZero)
-        this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
+        /*  establish a transform stream  */
+        const self = this
+        let firstChunk = true
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (!Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else if (firstChunk) {
+                    if (self.params.mode === "encode") {
+                        /*  convert raw/PCM to WAV/PCM
+                            (NOTICE: as this is a continuous stream, the
+                            resulting WAV header is not 100% conforming
+                            to the WAV standard, as it has to use a zero
+                            duration information. This cannot be changed in
+                            a stream-based processing.)  */
+                        const headerBuffer = writeWavHeader(0, {
+                            audioFormat: 0x0001 /* PCM */,
+                            channels:    self.config.audioChannels,
+                            sampleRate:  self.config.audioSampleRate,
+                            bitDepth:    self.config.audioBitDepth
+                        })
+                        const headerChunk = chunk.clone()
+                        headerChunk.payload = headerBuffer
+                        this.push(headerChunk)
+                        this.push(chunk)
+                        callback()
+                    }
+                    else if (self.params.mode === "decode") {
+                        /*  convert WAV/PCM to raw/PCM  */
+                        const header = readWavHeader(chunk.payload)
+                        self.log("info", "WAV audio stream: " +
+                            `audioFormat=${header.audioFormat === 0x0001 ? "PCM" :
+                                "0x" + (header.audioFormat as number).toString(16).padStart(4, "0")} ` +
+                            `channels=${header.channels} ` +
+                            `sampleRate=${header.sampleRate} ` +
+                            `bitDepth=${header.bitDepth}`)
+                        if (header.audioFormat !== 0x0001 /* PCM */)
+                            throw new Error("WAV not based on PCM format")
+                        if (header.bitDepth !== 16)
+                            throw new Error("WAV not based on 16 bit samples")
+                        if (header.sampleRate !== 48000)
+                            throw new Error("WAV not based on 48Khz sample rate")
+                        if (header.channels !== 1)
+                            throw new Error("WAV not based on mono channel")
+                        chunk.payload = chunk.payload.subarray(44)
+                        this.push(chunk)
+                        callback()
+                    }
+                    else
+                        throw new Error(`invalid operation mode "${self.params.mode}"`)
+                }
+                else {
+                    /*  pass-through original chunk  */
+                    this.push(chunk)
+                    callback()
+                }
+                firstChunk = false
+            },
+            final (callback) {
+                this.push(null)
+                callback()
+            }
+        })
     }
 
     /*  close node  */

package/src/speechflow-node-a2t-deepgram.ts

@@ -5,7 +5,7 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream from "node:stream"
 
 /*  external dependencies  */
 import * as Deepgram          from "@deepgram/sdk"
@@ -29,7 +29,8 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            key:      { type: "string", val: process.env.SPEECHFLOW_KEY_DEEPGRAM },
+            key:      { type: "string", val: process.env.SPEECHFLOW_DEEPGRAM_KEY },
+            keyAdm:   { type: "string", val: process.env.SPEECHFLOW_DEEPGRAM_KEY_ADM },
             model:    { type: "string", val: "nova-3", pos: 0 },
             version:  { type: "string", val: "latest", pos: 1 },
             language: { type: "string", val: "multi",  pos: 2 }
@@ -40,6 +41,21 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
         this.output = "text"
     }
 
+    /*  one-time status of node  */
+    async status () {
+        let balance  = 0
+        const deepgram = Deepgram.createClient(this.params.keyAdm)
+        const response = await deepgram.manage.getProjects()
+        if (response !== null && response.error === null) {
+            for (const project of response.result.projects) {
+                const response = await deepgram.manage.getProjectBalances(project.project_id)
+                if (response !== null && response.error === null)
+                    balance += response.result.balances[0]?.amount ?? 0
+            }
+        }
+        return { balance: balance.toFixed(2) }
+    }
+
     /*  open node  */
     async open () {
         /*  sanity check situation  */
@@ -49,6 +65,9 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
         /*  create queue for results  */
         const queue = new utils.SingleQueue<SpeechFlowChunk>()
 
+        /*  create a store for the meta information  */
+        const metastore = new utils.TimeStore<Map<string, any>>()
+
         /*  connect to Deepgram API  */
         const deepgram = Deepgram.createClient(this.params.key)
         let language = "en"
@@ -70,21 +89,27 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
             smart_format:     true,
             punctuate:        true,
             filler_words:     true,
-            diarize:          true, /* still not used by us */
+            diarize:          false,
             numerals:         true,
             profanity_filter: false
         })
 
         /*  hook onto Deepgram API events  */
         this.dg.on(Deepgram.LiveTranscriptionEvents.Transcript, async (data) => {
-            const text = (data.channel?.alternatives[0].transcript as string) ?? ""
+            const text = (data.channel?.alternatives[0]?.transcript as string) ?? ""
             if (text === "")
                 this.log("info", `Deepgram: empty/dummy text received (start: ${data.start}s, duration: ${data.duration}s)`)
             else {
                 this.log("info", `Deepgram: text received (start: ${data.start}s, duration: ${data.duration}s): "${text}"`)
                 const start = Duration.fromMillis(data.start * 1000).plus(this.timeZeroOffset)
                 const end   = start.plus({ seconds: data.duration })
-                const chunk = new SpeechFlowChunk(start, end, "final", "text", text)
+                const metas = metastore.fetch(start, end)
+                const meta = metas.reduce((prev: Map<string, any>, curr: Map<string, any>) => {
+                    curr.forEach((val, key) => { prev.set(key, val) })
+                    return prev
+                }, new Map<string, any>())
+                metastore.prune(start)
+                const chunk = new SpeechFlowChunk(start, end, "final", "text", text, meta)
                 queue.write(chunk)
             }
         })
@@ -164,6 +189,8 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
                     if (chunk.payload.byteLength > 0) {
                         log("info", `Deepgram: send data (${chunk.payload.byteLength} bytes)`)
                         initTimeoutStart()
+                        if (chunk.meta.size > 0)
+                            metastore.store(chunk.timestampStart, chunk.timestampEnd, chunk.meta)
                         dg.send(chunk.payload.buffer) /* intentionally discard all time information  */
                     }
                     callback()

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

@@ -5,7 +5,7 @@
 */
 
 /*  standard dependencies  */
-import Stream                from "node:stream"
+import Stream from "node:stream"
 
 /*  external dependencies  */
 import * as ElevenLabs       from "@elevenlabs/elevenlabs-js"
@@ -30,11 +30,13 @@ export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            key:      { type: "string", val: process.env.SPEECHFLOW_KEY_ELEVENLABS },
-            voice:    { type: "string", val: "Brian",   pos: 0, match: /^(?:.+)$/ },
-            language: { type: "string", val: "en",      pos: 1, match: /^(?:de|en)$/ },
-            speed:    { type: "number", val: 1.05,      pos: 2, match: (n: number) => n >= 0.7 && n <= 1.2 },
-            optimize: { type: "string", val: "latency", pos: 3, match: /^(?:latency|quality)$/ }
+            key:        { type: "string", val: process.env.SPEECHFLOW_ELEVENLABS_KEY },
+            voice:      { type: "string", val: "Brian",   pos: 0, match: /^(?:Brittney|Cassidy|Leonie|Mark|Brian)$/ },
+            language:   { type: "string", val: "en",      pos: 1, match: /^(?:de|en)$/ },
+            speed:      { type: "number", val: 1.00,      pos: 2, match: (n: number) => n >= 0.7 && n <= 1.2 },
+            stability:  { type: "number", val: 0.5,       pos: 3, match: (n: number) => n >= 0.0 && n <= 1.0 },
+            similarity: { type: "number", val: 0.75,      pos: 4, match: (n: number) => n >= 0.0 && n <= 1.0 },
+            optimize:   { type: "string", val: "latency", pos: 5, match: /^(?:latency|quality)$/ }
         })
 
         /*  declare node input/output format  */
@@ -42,6 +44,14 @@ export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
         this.output = "audio"
     }
 
+    /*  one-time status of node  */
+    async status () {
+        const elevenlabs = new ElevenLabs.ElevenLabsClient({ apiKey: this.params.key })
+        const subscription = await elevenlabs.user.subscription.get()
+        const percent = subscription.characterCount / subscription.characterLimit
+        return { usage: `${percent.toFixed(2)}%` }
+    }
+
     /*  open node  */
     async open () {
         /*  establish ElevenLabs API connection  */
@@ -82,7 +92,7 @@ export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
 
         /*  perform text-to-speech operation with Elevenlabs API  */
         const model = this.params.optimize === "quality" ?
-            "eleven_multilingual_v2" :
+            "eleven_turbo_v2_5" :
             "eleven_flash_v2_5"
         const speechStream = (text: string) => {
             this.log("info", `ElevenLabs: send text "${text}"`)
@@ -93,7 +103,9 @@ export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
                 outputFormat:     `pcm_${maxSampleRate}` as ElevenLabs.ElevenLabs.OutputFormat,
                 seed:             815, /* arbitrary, but fixated by us */
                 voiceSettings: {
-                    speed:        this.params.speed
+                    speed:           this.params.speed,
+                    stability:       this.params.stability,
+                    similarityBoost: this.params.similarity
                 }
             }, {
                 timeoutInSeconds: 30,
@@ -120,6 +132,7 @@ export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
                 if (Buffer.isBuffer(chunk.payload))
                     callback(new Error("invalid chunk payload type"))
                 else {
+                    log("info", `ElevenLabs: send text: ${JSON.stringify(chunk.payload)}`)
                     speechStream(chunk.payload).then((stream) => {
                         getStreamAsBuffer(stream).then((buffer) => {
                             const bufferResampled = resampler.processChunk(buffer)

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

@@ -5,11 +5,11 @@
 */
 
 /*  standard dependencies  */
-import Stream                from "node:stream"
+import Stream from "node:stream"
 
 /*  external dependencies  */
-import { KokoroTTS }         from "kokoro-js"
-import SpeexResampler        from "speex-resampler"
+import { KokoroTTS }  from "kokoro-js"
+import SpeexResampler from "speex-resampler"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"

package/src/speechflow-node-t2t-deepl.ts

@@ -5,10 +5,10 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream from "node:stream"
 
 /*  external dependencies  */
-import * as DeepL       from "deepl-node"
+import * as DeepL from "deepl-node"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
@@ -27,7 +27,7 @@ export default class SpeechFlowNodeDeepL extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            key:      { type: "string", val: process.env.SPEECHFLOW_KEY_DEEPL },
+            key:      { type: "string", val: process.env.SPEECHFLOW_DEEPL_KEY },
             src:      { type: "string", pos: 0, val: "de",      match: /^(?:de|en)$/ },
             dst:      { type: "string", pos: 1, val: "en",      match: /^(?:de|en)$/ },
             optimize: { type: "string", pos: 2, val: "latency", match: /^(?:latency|quality)$/ }
@@ -42,6 +42,14 @@ export default class SpeechFlowNodeDeepL extends SpeechFlowNode {
         this.output = "text"
     }
 
+    /*  one-time status of node  */
+    async status () {
+        this.deepl = new DeepL.Translator(this.params.key)
+        const usage = await this.deepl.getUsage()
+        const percent = (usage?.character?.count ?? 0) / (usage?.character?.limit ?? 0) * 100
+        return { usage: `${percent.toFixed(8)}%` }
+    }
+
     /*  open node  */
     async open () {
         /*  instantiate DeepL API SDK  */

package/src/speechflow-node-t2t-format.ts

@@ -5,10 +5,10 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream   from "node:stream"
 
 /*  external dependencies  */
-import wrapText         from "wrap-text"
+import wrapText from "wrap-text"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"

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

@@ -5,10 +5,10 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream     from "node:stream"
 
 /*  external dependencies  */
-import { Ollama }       from "ollama"
+import { Ollama } from "ollama"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"

package/src/speechflow-node-t2t-openai.ts

@@ -5,10 +5,10 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream from "node:stream"
 
 /*  external dependencies  */
-import OpenAI           from "openai"
+import OpenAI from "openai"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
@@ -149,7 +149,7 @@ export default class SpeechFlowNodeOpenAI extends SpeechFlowNode {
         this.configure({
             src:   { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/   },
             dst:   { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/   },
-            key:   { type: "string", val: process.env.SPEECHFLOW_KEY_OPENAI },
+            key:   { type: "string", val: process.env.SPEECHFLOW_OPENAI_KEY },
             api:   { type: "string", val: "https://api.openai.com/v1", match: /^https?:\/\/.+?:\d+$/ },
             model: { type: "string", val: "gpt-4o-mini" }
         })

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

@@ -5,7 +5,7 @@
 */
 
 /*  standard dependencies  */
-import Stream           from "node:stream"
+import Stream from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"

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

@@ -5,8 +5,8 @@
 */
 
 /*  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"

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

@@ -0,0 +1,122 @@
+/*
+**  SpeechFlow - Speech Processing Flow Graph
+**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+
+/*  standard dependencies  */
+import Stream from "node:stream"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+
+/*  SpeechFlow node for data flow filtering (based on meta information)  */
+export default class SpeechFlowNodeFilter extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "filter"
+
+    /*  construct node  */
+    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
+        super(id, cfg, opts, args)
+
+        /*  declare node configuration parameters  */
+        this.configure({
+            type: { type: "string", pos: 0, val: "audio", match: /^(?:audio|text)$/ },
+            var:  { type: "string", pos: 1, val: "",      match: /^(?:meta:.+|payload:(?:length|text)|time:(?:start|end))$/ },
+            op:   { type: "string", pos: 2, val: "==",    match: /^(?:<|<=|==|!=|~~|!~|>=|>)$/ },
+            val:  { type: "string", pos: 3, val: "",      match: /^.*$/ }
+        })
+
+        /*  declare node input/output format  */
+        this.input  = this.params.type
+        this.output = this.params.type
+    }
+
+    /*  open node  */
+    async open () {
+        /*  helper function for comparing two values  */
+        const comparison = (val1: any, op: string, val2: any) => {
+            if (op === "==" || op === "!=") {
+                /*  equal comparison  */
+                const str1 = (typeof val1 === "string" ? val1 : val1.toString()) as string
+                const str2 = (typeof val2 === "string" ? val2 : val2.toString()) as string
+                return (op === "==" ? (str1 === str2) : (str1 !== str2))
+            }
+            else if (op === "~~" || op === "!~") {
+                /*  regular expression comparison  */
+                const str = (typeof val1 === "string" ? val1 : val1.toString()) as string
+                const regexp = (
+                    val2 instanceof RegExp ?
+                        val2 :
+                        typeof val2 === "string" ?
+                            new RegExp(val2) :
+                            new RegExp(val2.toString()))
+                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) : (
+                            typeof val === "string" && val.match(/^[\d.+-]+$/) ?
+                                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
+                )
+            }
+        }
+
+        /*  provide Transform stream  */
+        const self = this
+        this.stream = new Stream.Transform({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                let val1: any
+                const val2: any = self.params.val
+                const m = self.params.var.match(/^meta:(.+)$/)
+                if (m !== null)
+                    val1 = chunk.meta.get(m[1])
+                else if (self.params.key === "payload:length")
+                    val1 = chunk.payload.length
+                else if (self.params.key === "payload:text")
+                    val1 = (self.params.type === "text" ? chunk.payload as string : "")
+                else if (self.params.key === "time:start")
+                    val1 = chunk.timestampStart.toMillis()
+                else if (self.params.key === "time:end")
+                    val1 = chunk.timestampEnd.toMillis()
+                if (comparison(val1, self.params.ops, val2))
+                    this.push(chunk)
+                callback()
+            },
+            final (callback) {
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+    }
+}