speechflow 1.6.7 → 1.7.1

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

@@ -91,7 +91,7 @@ export function convertBufToI16 (buf: Buffer, littleEndian = true) {
     return arr
 }
 
-/*  helper function: convert In16Array in PCM/I16 to Buffer  */
+/*  helper function: convert Int16Array in PCM/I16 to Buffer  */
 export function convertI16ToBuf (arr: Int16Array, littleEndian = true) {
     if (arr.length === 0)
         return Buffer.alloc(0)
@@ -133,7 +133,7 @@ export async function processInt16ArrayInSegments (
 }
 
 /*  update envelope (smoothed amplitude contour) for single channel  */
-export function updateEnvelopeForChannel(
+export function updateEnvelopeForChannel (
     env:            number[],
     sampleRate:     number,
     chan:           number,
@@ -182,7 +182,7 @@ export class WebAudio {
     }>()
 
     /*  construct object  */
-    constructor(
+    constructor (
         public sampleRate: number,
         public channels: number
     ) {
@@ -215,7 +215,7 @@ export class WebAudio {
             numberOfInputs:  1,
             numberOfOutputs: 0
         })
-        this.captureNode!.port.addEventListener("message", (event) => {
+        this.captureNode.port.addEventListener("message", (event) => {
             const { type, chunkId, data } = event.data ?? {}
             if (type === "capture-complete") {
                 const promise = this.pendingPromises.get(chunkId)
@@ -232,7 +232,7 @@ export class WebAudio {
 
         /*  start ports  */
         this.sourceNode.port.start()
-        this.captureNode!.port.start()
+        this.captureNode.port.start()
     }
 
     /*  process single audio chunk  */
@@ -242,7 +242,7 @@ export class WebAudio {
             const timeout = setTimeout(() => {
                 this.pendingPromises.delete(chunkId)
                 reject(new Error("processing timeout"))
-            }, (int16Array.length / this.audioContext.sampleRate) * 1000 + 250)
+            }, (int16Array.length / this.channels / this.audioContext.sampleRate) * 1000 + 250)
             if (this.captureNode !== null)
                 this.pendingPromises.set(chunkId, { resolve, reject, timeout })
             try {
@@ -252,7 +252,7 @@ export class WebAudio {
 
                 /*  start capture first  */
                 if (this.captureNode !== null) {
-                    this.captureNode?.port.postMessage({
+                    this.captureNode.port.postMessage({
                         type: "start-capture",
                         chunkId,
                         expectedSamples: int16Array.length

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

@@ -4,13 +4,6 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
-/*  helper function for promise-based timeout  */
-export function timeoutPromise<T = void> (duration: number = 10 * 1000, info = "timeout") {
-    return new Promise<T>((resolve, reject) => {
-        setTimeout(() => { reject(new Error(info)) }, duration)
-    })
-}
-
 /*  helper function for retrieving an Error object  */
 export function ensureError (error: unknown, prefix?: string, debug = false): Error {
     if (error instanceof Error && prefix === undefined && debug === false)

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

@@ -0,0 +1,23 @@
+/*
+**  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>
+*/
+
+/*  sleep: wait a duration of time and then resolve  */
+export function sleep (durationMs: number) {
+    return new Promise<void>((resolve) => {
+        setTimeout(() => {
+            resolve()
+        }, durationMs)
+    })
+}
+
+/*  timeout: wait a duration of time and then reject  */
+export function timeout (durationMs: number, info = "timeout") {
+    return new Promise<never>((_resolve, reject) => {
+        setTimeout(() => {
+            reject(new Error(info))
+        }, durationMs)
+    })
+}

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

@@ -34,12 +34,10 @@ export class SingleQueue<T> extends EventEmitter {
         this.emit("dequeue")
     }
     read () {
-        return new Promise<T>((resolve, reject) => {
-            const consume = () =>
-                this.queue.length > 0 ? this.queue.pop()! : null
+        return new Promise<T>((resolve) => {
             const tryToConsume = () => {
-                const item = consume()
-                if (item !== null)
+                const item = this.queue.pop()
+                if (item !== undefined)
                     resolve(item)
                 else
                     this.once("dequeue", tryToConsume)
@@ -47,6 +45,11 @@ export class SingleQueue<T> extends EventEmitter {
             tryToConsume()
         })
     }
+    drain () {
+        const items = this.queue
+        this.queue = new Array<T>()
+        return items
+    }
 }
 
 /*  helper class for double-item queue  */
@@ -66,18 +69,18 @@ export class DoubleQueue<T0, T1> extends EventEmitter {
         this.notify()
     }
     read () {
-        return new Promise<[ T0, T1 ]>((resolve, reject) => {
-            const consume = (): [ T0, T1 ] | null => {
+        return new Promise<[ T0, T1 ]>((resolve) => {
+            const consume = (): [ T0, T1 ] | undefined => {
                 if (this.queue0.length > 0 && this.queue1.length > 0) {
                     const item0 = this.queue0.pop() as T0
                     const item1 = this.queue1.pop() as T1
                     return [ item0, item1 ]
                 }
-                return null
+                return undefined
             }
             const tryToConsume = () => {
                 const items = consume()
-                if (items !== null)
+                if (items !== undefined)
                     resolve(items)
                 else
                     this.once("dequeue", tryToConsume)
@@ -87,7 +90,7 @@ export class DoubleQueue<T0, T1> extends EventEmitter {
     }
 }
 
-/*  queue element */
+/*  queue element  */
 export type QueueElement = { type: string }
 
 /*  queue pointer  */
@@ -225,7 +228,7 @@ export class Queue<T extends QueueElement> extends EventEmitter {
     }
     pointerDelete (name: string): void {
         if (!this.pointers.has(name))
-            throw new Error("pointer not exists")
+            throw new Error("pointer does not exist")
         this.pointers.delete(name)
     }
     trim (): void {
@@ -273,12 +276,12 @@ export class TimeStore<T> extends EventEmitter {
 
 /*  asynchronous queue  */
 export class AsyncQueue<T> {
-    private queue: Array<T | null> = []
-    private resolvers: ((v: T | null) => void)[] = []
-    write (v: T | null) {
-        const resolve = this.resolvers.shift()
-        if (resolve)
-            resolve(v)
+    private queue: Array<T> = []
+    private resolvers: { resolve: (v: T) => void, reject: (err: Error) => void }[] = []
+    write (v: T) {
+        const resolver = this.resolvers.shift()
+        if (resolver)
+            resolver.resolve(v)
         else
             this.queue.push(v)
     }
@@ -286,11 +289,14 @@ export class AsyncQueue<T> {
         if (this.queue.length > 0)
             return this.queue.shift()!
         else
-            return new Promise<T | null>((resolve) => this.resolvers.push(resolve))
+            return new Promise<T>((resolve, reject) => this.resolvers.push({ resolve, reject }))
+    }
+    empty () {
+        return this.queue.length === 0
     }
     destroy () {
-        for (const resolve of this.resolvers)
-            resolve(null)
+        for (const resolver of this.resolvers)
+            resolver.reject(new Error("AsyncQueue destroyed"))
         this.resolvers = []
         this.queue = []
     }
@@ -318,3 +324,17 @@ export class CachedRegExp {
         return this.cache.size
     }
 }
+
+/*  set of promises  */
+export class PromiseSet<T> {
+    private promises = new Set<Promise<T>>()
+    add (promise: Promise<T>) {
+        this.promises.add(promise)
+        promise.finally(() => {
+            this.promises.delete(promise)
+        }).catch(() => {})
+    }
+    async awaitAll () {
+        await Promise.all(this.promises)
+    }
+}

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

@@ -16,38 +16,43 @@ import { SpeechFlowChunk }     from "./speechflow-node"
 import * as util               from "./speechflow-util"
 
 /*  create a Duplex/Transform stream which has
-    object-mode on Writable side and buffer/string-mode on Readable side  */
-export function createTransformStreamForWritableSide () {
+    object-mode        on Writable side and
+    buffer/string-mode on Readable side  */
+export function createTransformStreamForWritableSide (
+    type: "text" | "audio",
+    readableHighWaterMark?: number
+) {
     return new Stream.Transform({
-        readableObjectMode: true,
-        writableObjectMode: true,
-        decodeStrings: false,
-        highWaterMark: 1,
+        writableObjectMode:    true,
+        readableObjectMode:    false,
+        writableHighWaterMark: 1,
+        readableHighWaterMark: readableHighWaterMark ?? (type === "audio" ? 19200 /* 400ms */ : 65536 /* 64KB */),
+        decodeStrings:         false,
         transform (chunk: SpeechFlowChunk, encoding, callback) {
             this.push(chunk.payload)
             callback()
         },
         final (callback) {
-            this.push(null)
             callback()
         }
     })
 }
 
 /*  create a Duplex/Transform stream which has
-    object-mode on Readable side and buffer/string-mode on Writable side  */
-export function createTransformStreamForReadableSide (type: "text" | "audio", getTimeZero: () => DateTime, highWaterMark?: number) {
+    buffer/string-mode on Writable side and
+    object-mode        on Readable side  */
+export function createTransformStreamForReadableSide (
+    type: "text" | "audio",
+    getTimeZero: () => DateTime,
+    writableHighWaterMark?: number
+) {
     return new Stream.Transform({
-        readableObjectMode: true,
-        writableObjectMode: true,
-        decodeStrings: false,
-        highWaterMark: highWaterMark ?? (type === "audio" ? 19200 /* 400ms */: 65536 /* 64KB */),
+        writableObjectMode:    false,
+        readableObjectMode:    true,
+        writableHighWaterMark: writableHighWaterMark ?? (type === "audio" ? 19200 /* 400ms */ : 65536 /* 64KB */),
+        readableHighWaterMark: 1,
+        decodeStrings:         false,
         transform (chunk: Buffer | string, encoding, callback) {
-            if (chunk === null) {
-                this.push(null)
-                callback()
-                return
-            }
             const timeZero = getTimeZero()
             const start = DateTime.now().diff(timeZero)
             let end = start
@@ -61,7 +66,6 @@ export function createTransformStreamForReadableSide (type: "text" | "audio", ge
             callback()
         },
         final (callback) {
-            this.push(null)
             callback()
         }
     })
@@ -110,8 +114,7 @@ export function streamChunkEncode (chunk: SpeechFlowChunk) {
     }
     if (chunk.meta.size > 0)
         data.meta = Array.from(chunk.meta.entries())
-    const _data = CBOR.encode(data)
-    return _data
+    return CBOR.encode(data)
 }
 
 /*  decode/unserialize chunk of data  */
@@ -201,7 +204,7 @@ export class StreamWrapper extends Stream.Transform {
 }
 
 /*  helper function for destruction of a stream  */
-export async function destroyStream(
+export async function destroyStream (
     stream: Stream.Readable | Stream.Writable | Stream.Duplex | Stream.Transform
 ) {
     /*  signal the end for a writable stream  */
@@ -214,8 +217,10 @@ export async function destroyStream(
             new Promise<void>((resolve) => {
                 stream.end(() => { resolve() })
             }),
-            util.timeoutPromise(5000, "stream end timeout")
-        ])
+            util.timeout(5000, "stream end timeout")
+        ]).catch(() => {
+            /*  ignore timeout -- stream will be destroyed anyway  */
+        })
 
     /*  destroy the stream  */
     stream.destroy()

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

@@ -8,3 +8,4 @@ export * from "./speechflow-util-audio"
 export * from "./speechflow-util-error"
 export * from "./speechflow-util-stream"
 export * from "./speechflow-util-queue"
+export * from "./speechflow-util-misc"