speechflow 1.5.0 → 1.5.1

package/speechflow-cli/package.json

@@ -32,6 +32,7 @@
         "@aws-sdk/client-transcribe-streaming": "3.879.0",
         "@aws-sdk/client-translate":            "3.879.0",
         "@aws-sdk/client-polly":                "3.879.0",
+        "@google-cloud/translate":              "9.2.0",
         "node-web-audio-api":                   "1.0.4",
         "object-path":                          "0.11.8",
         "ws":                                   "8.18.3",
@@ -44,7 +45,7 @@
         "hapi-plugin-websocket":                "2.4.11",
         "@opensumi/reconnecting-websocket":     "4.4.0",
         "ollama":                               "0.5.17",
-        "openai":                               "5.16.0",
+        "openai":                               "5.18.0",
         "@rse/ffmpeg":                          "1.4.2",
         "ffmpeg-stream":                        "1.0.1",
         "installed-packages":                   "1.0.13",
@@ -64,7 +65,7 @@
         "node-interval-tree":                   "2.1.2",
         "wrap-text":                            "1.0.10",
         "cli-table3":                           "0.6.5",
-        "@rse/stx":                             "1.0.9"
+        "@rse/stx":                             "1.1.0"
     },
     "devDependencies": {
         "eslint":                               "9.34.0",
@@ -73,9 +74,9 @@
         "eslint-plugin-promise":                "7.2.1",
         "eslint-plugin-import":                 "2.32.0",
         "eslint-plugin-node":                   "11.1.0",
-        "typescript-eslint":                    "8.41.0",
-        "@typescript-eslint/eslint-plugin":     "8.41.0",
-        "@typescript-eslint/parser":            "8.41.0",
+        "typescript-eslint":                    "8.42.0",
+        "@typescript-eslint/eslint-plugin":     "8.42.0",
+        "@typescript-eslint/parser":            "8.42.0",
         "oxlint":                               "1.14.0",
         "eslint-plugin-oxlint":                 "1.14.0",
         "@biomejs/biome":                       "2.0.6",

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

@@ -255,8 +255,8 @@ export default class SpeechFlowNodeCompressor extends SpeechFlowNode {
                         }
                         this.push(chunk)
                         callback()
-                    }).catch((error) => {
-                        callback(new Error(`compression failed: ${error}`))
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error, "compression failed"))
                     })
                 }
             },

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

@@ -176,8 +176,8 @@ export default class SpeechFlowNodeExpander extends SpeechFlowNode {
                         chunk.payload = payload
                         this.push(chunk)
                         callback()
-                    }).catch((error) => {
-                        callback(new Error(`expansion failed: ${error}`))
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error, "expansion failed"))
                     })
                 }
             },

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

@@ -90,12 +90,7 @@ export default class SpeechFlowNodeFFmpeg extends SpeechFlowNode {
                 "f":           "opus"
             } : {})
         })
-        try {
-            this.ffmpeg.run()
-        }
-        catch (err) {
-            throw new Error(`failed to start FFmpeg process: ${err}`)
-        }
+        utils.run("starting FFmpeg process", () => this.ffmpeg!.run())
 
         /*  establish a duplex stream and connect it to FFmpeg  */
         this.stream = Stream.Duplex.from({
@@ -125,12 +120,7 @@ export default class SpeechFlowNodeFFmpeg extends SpeechFlowNode {
 
         /*  shutdown FFmpeg  */
         if (this.ffmpeg !== null) {
-            try {
-                this.ffmpeg.kill()
-            }
-            catch {
-                /*  ignore kill errors during cleanup  */
-            }
+            utils.run(() => this.ffmpeg!.kill(), () => {})
             this.ffmpeg = null
         }
     }

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

@@ -180,9 +180,9 @@ export default class SpeechFlowNodeFiller extends SpeechFlowNode {
                         self.log("debug", `received data (${chunk.payload.length} bytes)`)
                         this.push(chunk)
                     }
-                }).catch((error) => {
+                }).catch((error: unknown) => {
                     if (!self.destroyed)
-                        self.log("error", `queue read error: ${error.message}`)
+                        self.log("error", `queue read error: ${utils.ensureError(error).message}`)
                 })
             },
             final (callback) {

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

@@ -224,8 +224,8 @@ export default class SpeechFlowNodeAWSTranscribe extends SpeechFlowNode {
                         if (chunk.meta.size > 0)
                             metastore.store(chunk.timestampStart, chunk.timestampEnd, chunk.meta)
                         audioQueue.push(new Uint8Array(chunk.payload)) /* intentionally discard all time information */
-                        ensureAudioStreamActive().catch((err) => {
-                            self.log("error", `failed to start audio stream: ${err}`)
+                        ensureAudioStreamActive().catch((error: unknown) => {
+                            self.log("error", `failed to start audio stream: ${utils.ensureError(error).message}`)
                         })
                     }
                     callback()
@@ -249,9 +249,9 @@ export default class SpeechFlowNodeAWSTranscribe extends SpeechFlowNode {
                         self.log("debug", `received data (${chunk.payload.length} bytes): "${chunk.payload}"`)
                         this.push(chunk)
                     }
-                }).catch((error) => {
+                }).catch((error: unknown) => {
                     if (!self.destroyed)
-                        self.log("error", `queue read error: ${error.message}`)
+                        self.log("error", `queue read error: ${utils.ensureError(error).message}`)
                 })
             },
             final (callback) {
@@ -259,12 +259,10 @@ export default class SpeechFlowNodeAWSTranscribe extends SpeechFlowNode {
                     callback()
                     return
                 }
-                try {
-                    self.client.destroy()
-                }
-                catch (error) {
-                    self.log("warning", `error closing Amazon Transcribe connection: ${error}`)
-                }
+                utils.run(
+                    () => self.client!.destroy(),
+                    (error: Error) => self.log("warning", `error closing Amazon Transcribe connection: ${error}`)
+                )
                 audioQueue.push(null) /* do not push null to stream, let Amazon Transcribe do it */
                 audioQueue.destroy()
                 callback()

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

@@ -232,9 +232,9 @@ export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
                         self.log("debug", `received data (${chunk.payload.length} bytes)`)
                         this.push(chunk)
                     }
-                }).catch((error) => {
+                }).catch((error: unknown) => {
                     if (!self.destroyed)
-                        self.log("error", `queue read error: ${error.message}`)
+                        self.log("error", `queue read error: ${utils.ensureError(error).message}`)
                 })
             },
             final (callback) {

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

@@ -279,9 +279,9 @@ export default class SpeechFlowNodeOpenAITranscribe extends SpeechFlowNode {
                         self.log("debug", `received data (${chunk.payload.length} bytes)`)
                         this.push(chunk)
                     }
-                }).catch((error) => {
+                }).catch((error: unknown) => {
                     if (!self.destroyed)
-                        self.log("error", `queue read error: ${error.message}`)
+                        self.log("error", `queue read error: ${utils.ensureError(error).message}`)
                 })
             },
             final (callback) {

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

@@ -17,6 +17,7 @@ import {
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  SpeechFlow node for AWS Polly text-to-speech conversion  */
 export default class SpeechFlowNodeAWSPolly extends SpeechFlowNode {
@@ -144,9 +145,8 @@ export default class SpeechFlowNodeAWSPolly extends SpeechFlowNode {
                         chunkNew.payload = buffer
                         this.push(chunkNew)
                         callback()
-                    }).catch((error) => {
-                        callback(error instanceof Error ?
-                            error : new Error(`failed to send to AWS Polly: ${String(error)}`))
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error, "failed to send to AWS Polly"))
                     })
                 }
                 else

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

@@ -13,6 +13,7 @@ import SpeexResampler from "speex-resampler"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  SpeechFlow node for Kokoro text-to-speech conversion  */
 export default class SpeechFlowNodeKokoro extends SpeechFlowNode {
@@ -141,8 +142,8 @@ export default class SpeechFlowNodeKokoro extends SpeechFlowNode {
                         chunk.payload = buffer
                         this.push(chunk)
                         callback()
-                    }).catch((err) => {
-                        callback(err)
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
                     })
                 }
             },

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

@@ -12,6 +12,7 @@ import { TranslateClient, TranslateTextCommand } from "@aws-sdk/client-translate
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  SpeechFlow node for AWS Translate text-to-text translations  */
 export default class SpeechFlowNodeAWSTranslate extends SpeechFlowNode {
@@ -122,8 +123,8 @@ export default class SpeechFlowNodeAWSTranslate extends SpeechFlowNode {
                         chunkNew.payload = payload
                         this.push(chunkNew)
                         callback()
-                    }).catch((err) => {
-                        callback(err)
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
                     })
                 }
             },

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

@@ -12,6 +12,7 @@ import * as DeepL from "deepl-node"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  SpeechFlow node for DeepL text-to-text translations  */
 export default class SpeechFlowNodeDeepL extends SpeechFlowNode {
@@ -93,8 +94,8 @@ export default class SpeechFlowNodeDeepL extends SpeechFlowNode {
                         chunkNew.payload = payload
                         this.push(chunkNew)
                         callback()
-                    }).catch((err) => {
-                        callback(err)
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
                     })
                 }
             },

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

@@ -0,0 +1,133 @@
+/*
+**  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"
+
+/*  external dependencies  */
+import { TranslationServiceClient } from "@google-cloud/translate"
+import * as arktype                 from "arktype"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
+
+/*  SpeechFlow node for Google Translate text-to-text translations  */
+export default class SpeechFlowNodeGoogle extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "google"
+
+    /*  internal state  */
+    private client: TranslationServiceClient | null = null
+
+    /*  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({
+            key: { type: "string",         val: process.env.SPEECHFLOW_GOOGLE_KEY ?? "" },
+            src: { type: "string", pos: 0, val: "de", match: /^(?:de|en|fr|it)$/ },
+            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en|fr|it)$/ }
+        })
+
+        /*  validate API key and project  */
+        if (this.params.key === "")
+            throw new Error("Google Cloud API credentials JSON key is required")
+
+        /*  sanity check situation  */
+        if (this.params.src === this.params.dst)
+            throw new Error("source and destination languages cannot be the same")
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "text"
+    }
+
+    /*  one-time status of node  */
+    async status () {
+        return {}
+    }
+
+    /*  open node  */
+    async open () {
+        /*  instantiate Google Translate client  */
+        const data = utils.run("Google Cloud API credentials key", () =>
+            JSON.parse(this.params.key))
+        const credentials = utils.importObject("Google Cloud API credentials key",
+            data,
+            arktype.type({
+                project_id:   "string",
+                private_key:  "string",
+                client_email: "string",
+            })
+        )
+        this.client = new TranslationServiceClient({
+            credentials: {
+                private_key:  credentials.private_key,
+                client_email: credentials.client_email
+            },
+            projectId: credentials.project_id
+        })
+
+        /*  provide text-to-text translation  */
+        const translate = utils.runner("Google Translate API", async (text: string) => {
+            const [ response ] = await this.client!.translateText({
+                parent:   `projects/${credentials.project_id}/locations/global`,
+                contents: [ text ],
+                mimeType: "text/plain",
+                sourceLanguageCode: this.params.src,
+                targetLanguageCode: this.params.dst
+            })
+            return response.translations?.[0]?.translatedText ?? text
+        })
+
+        /*  establish a duplex stream and connect it to Google Translate  */
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            highWaterMark:      1,
+            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 {
+                    translate(chunk.payload).then((payload) => {
+                        const chunkNew = chunk.clone()
+                        chunkNew.payload = payload
+                        this.push(chunkNew)
+                        callback()
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
+                    })
+                }
+            },
+            final (callback) {
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+
+        /*  shutdown Google Translate client  */
+        if (this.client !== null) {
+            this.client.close()
+            this.client = null
+        }
+    }
+}

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

@@ -12,6 +12,7 @@ import { Ollama, type ListResponse } from "ollama"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  internal utility types  */
 type ConfigEntry = { systemPrompt: string, chat: Array<{ role: string, content: string }> }
@@ -250,8 +251,8 @@ export default class SpeechFlowNodeOllama extends SpeechFlowNode {
                             chunkNew.payload = payload
                             this.push(chunkNew)
                             callback()
-                        }).catch((err) => {
-                            callback(err)
+                        }).catch((error: unknown) => {
+                            callback(utils.ensureError(error))
                         })
                     }
                 }

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

@@ -12,6 +12,7 @@ import OpenAI from "openai"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  internal utility types  */
 type ConfigEntry = { systemPrompt: string, chat: OpenAI.ChatCompletionMessageParam[] }
@@ -219,8 +220,8 @@ export default class SpeechFlowNodeOpenAI extends SpeechFlowNode {
                         chunkNew.payload = payload
                         this.push(chunkNew)
                         callback()
-                    }).catch((err) => {
-                        callback(err)
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
                     })
                 }
             },

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

@@ -18,6 +18,7 @@ import HAPIWebSocket from "hapi-plugin-websocket"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 type wsPeerCtx = {
     peer: string
@@ -145,8 +146,8 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
                                 chunkNew.payload = payload
                                 this.push(chunkNew)
                                 callback()
-                            }).catch((err) => {
-                                callback(err)
+                            }).catch((error: unknown) => {
+                                callback(utils.ensureError(error))
                             })
                         }
                     }

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

@@ -13,6 +13,7 @@ import * as Transformers from "@huggingface/transformers"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
 
 /*  internal utility types  */
 type ConfigEntry = { systemPrompt: string, chat: Array<{ role: string, content: string }> }
@@ -212,8 +213,8 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                         chunk.payload = payload
                         this.push(chunk)
                         callback()
-                    }).catch((err) => {
-                        callback(err)
+                    }).catch((error: unknown) => {
+                        callback(utils.ensureError(error))
                     })
                 }
             },

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

@@ -7,6 +7,7 @@
 /*  standard dependencies  */
 import Stream                 from "node:stream"
 import { EventEmitter }       from "node:events"
+import { type, type Type }    from "arktype"
 
 /*  external dependencies  */
 import { DateTime, Duration } from "luxon"
@@ -16,6 +17,194 @@ import * as IntervalTree      from "node-interval-tree"
 /*  internal dependencies  */
 import { SpeechFlowChunk }    from "./speechflow-node"
 
+/*  helper function for retrieving an Error object  */
+export function ensureError (error: unknown, prefix?: string): Error {
+    if (error instanceof Error && prefix === undefined)
+        return error
+    let msg = error instanceof Error ?
+        error.message : String(error)
+    if (prefix)
+        msg = `${prefix}: ${msg}`
+    return new Error(msg, { cause: error })
+}
+
+/*  helper function for retrieving a Promise object  */
+export function ensurePromise<T> (arg: T | Promise<T>): Promise<T> {
+    if (!(arg instanceof Promise))
+        arg = Promise.resolve(arg)
+    return arg
+}
+
+/*  helper function for running the finally code of "run"  */
+function runFinally (onfinally?: () => void) {
+    if (!onfinally)
+        return
+    try { onfinally() }
+    catch (_arg: unknown) { /*  ignored  */ }
+}
+
+/*  helper type for ensuring T contains no Promise  */
+type runNoPromise<T> =
+    [ T ] extends [ Promise<any> ] ? never : T
+
+/*  run a synchronous or asynchronous action  */
+export function run<T, X extends runNoPromise<T> | never> (
+    action:      () => X,
+    oncatch?:    (error: Error) => X | never,
+    onfinally?:  () => void
+): X
+export function run<T, X extends runNoPromise<T> | never> (
+    description: string,
+    action:      () => X,
+    oncatch?:    (error: Error) => X | never,
+    onfinally?:  () => void
+): X
+export function run<T, X extends (T | Promise<T>)> (
+    action:      () => X,
+    oncatch?:    (error: Error) => X,
+    onfinally?:  () => void
+): Promise<T>
+export function run<T, X extends (T | Promise<T>)> (
+    description: string,
+    action:      () => X,
+    oncatch?:    (error: Error) => X,
+    onfinally?:  () => void
+): Promise<T>
+export function run<T> (
+    ...args: any[]
+): T | Promise<T> | never {
+    /*  support overloaded signatures  */
+    let description: string | undefined
+    let action:      () => T | Promise<T> | never
+    let oncatch:     (error: Error) => T | Promise<T> | never
+    let onfinally:   () => void
+    if (typeof args[0] === "string") {
+        description = args[0]
+        action      = args[1]
+        oncatch     = args[2]
+        onfinally   = args[3]
+    }
+    else {
+        action      = args[0]
+        oncatch     = args[1]
+        onfinally   = args[2]
+    }
+
+    /*  perform the action  */
+    let result: T | Promise<T>
+    try {
+        result = action()
+    }
+    catch (arg: unknown) {
+        /*  synchronous case (error branch)  */
+        let error = ensureError(arg, description)
+        if (oncatch) {
+            try {
+                result = oncatch(error)
+            }
+            catch (arg: unknown) {
+                error = ensureError(arg, description)
+                runFinally(onfinally)
+                throw error
+            }
+            runFinally(onfinally)
+            return result
+        }
+        runFinally(onfinally)
+        throw error
+    }
+    if (result instanceof Promise) {
+        /*  asynchronous case (result or error branch)  */
+        return result.catch((arg: unknown) => {
+            /*  asynchronous case (error branch)  */
+            let error = ensureError(arg, description)
+            if (oncatch) {
+                try {
+                    return ensurePromise(oncatch(error))
+                }
+                catch (arg: unknown) {
+                    error = ensureError(arg, description)
+                    return Promise.reject(error)
+                }
+            }
+            return Promise.reject(error)
+        }).finally(() => {
+            /*  asynchronous case (result and error branch)  */
+            runFinally(onfinally)
+        })
+    }
+    else {
+        /*  synchronous case (result branch)  */
+        runFinally(onfinally)
+        return result
+    }
+}
+
+/*  run a synchronous or asynchronous action  */
+/* eslint @typescript-eslint/unified-signatures: off */
+export function runner<T, X extends runNoPromise<T> | never, F extends (...args: any[]) => X> (
+    action:      F,
+    oncatch?:    (error: Error) => X | never,
+    onfinally?:  () => void
+): F
+export function runner<T, X extends runNoPromise<T> | never, F extends (...args: any[]) => X> (
+    description: string,
+    action:      F,
+    oncatch?:    (error: Error) => X | never,
+    onfinally?:  () => void
+): F
+export function runner<T, X extends (T | Promise<T>), F extends (...args: any[]) => Promise<T>> (
+    action:      F,
+    oncatch?:    (error: Error) => X,
+    onfinally?:  () => void
+): F
+export function runner<T, X extends (T | Promise<T>), F extends (...args: any[]) => Promise<T>> (
+    description: string,
+    action:      F,
+    oncatch?:    (error: Error) => X,
+    onfinally?:  () => void
+): F
+export function runner<T> (
+    ...args: any[]
+): (...args: any[]) => T | Promise<T> | never {
+    /*  support overloaded signatures  */
+    let description: string | undefined
+    let action:      (...args: any[]) => T | Promise<T> | never
+    let oncatch:     (error: Error) => T | Promise<T> | never
+    let onfinally:   () => void
+    if (typeof args[0] === "string") {
+        description = args[0]
+        action      = args[1]
+        oncatch     = args[2]
+        onfinally   = args[3]
+    }
+    else {
+        action      = args[0]
+        oncatch     = args[1]
+        onfinally   = args[2]
+    }
+
+    /*  wrap the "run" operation on "action" into function
+        which exposes the signature of "action"  */
+    return (...args: any[]) => {
+        if (description)
+            return run(description, () => action(...args), oncatch, onfinally)
+        else
+            return run(() => action(...args), oncatch, onfinally)
+    }
+}
+
+/*  import an object with parsing and strict error handling  */
+export function importObject<T>(name: string, arg: object | string, validator: Type<T, {}>): T {
+    const obj: object = typeof arg === "string" ?
+        run(`${name}: parsing JSON`, () => JSON.parse(arg)) :
+        arg
+    const result = validator(obj)
+    if (result instanceof type.errors)
+        throw new Error(`${name}: validation: ${result.summary}`)
+    return result as T
+}
+
 /*  calculate duration of an audio buffer  */
 export function audioBufferDuration (
     buffer: Buffer,