speechflow 1.6.7 → 1.7.1

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

@@ -20,10 +20,16 @@ import HAPIWebSocket from "hapi-plugin-websocket"
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
 import * as util                           from "./speechflow-util"
 
+/*  internal helper types  */
 type WSPeerInfo = {
-    ctx:  Record<string, any>
-    ws:   WebSocket
-    req:  http.IncomingMessage
+    ctx:   Record<string, any>
+    ws:    WebSocket
+    req:   http.IncomingMessage
+}
+type TextChunk = {
+    start: Duration
+    end:   Duration
+    text:  string
 }
 
 /*  SpeechFlow node for subtitle (text-to-text) "translations"  */
@@ -43,14 +49,14 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
         this.configure({
             format: { type: "string",  pos: 0, val: "srt",    match: /^(?:srt|vtt)$/ },
             words:  { type: "boolean",         val: false },
-            mode:   { type: "string",          val: "export", match: /^(?:export|render)$/ },
+            mode:   { type: "string",          val: "export", match: /^(?:export|import|render)$/ },
             addr:   { type: "string",          val: "127.0.0.1" },
             port:   { type: "number",          val: 8585 }
         })
 
         /*  declare node input/output format  */
         this.input  = "text"
-        this.output = this.params.mode === "export" ? "text" : "none"
+        this.output = (this.params.mode === "export" || this.params.mode === "import") ? "text" : "none"
     }
 
     /*  open node  */
@@ -95,11 +101,18 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                     }
                     return text
                 }
-                let output = ""
+
+                /*  determine start and end timestamp,
+                    by using first word's start time and last word's end time (if available),
+                    to exclude leading and trailing silence parts  */
+                const words: { word: string, start: Duration, end: Duration }[] = chunk.meta.get("words") ?? []
+                const timestampStart = words.length > 0 ? words[0].start              : chunk.timestampStart
+                const timestampEnd   = words.length > 0 ? words[words.length - 1].end : chunk.timestampEnd
+
+                /*  produce SRT/VTT blocks  */
+                let output = convertSingle(timestampStart, timestampEnd, chunk.payload)
                 if (this.params.words) {
-                    output += convertSingle(chunk.timestampStart, chunk.timestampEnd, chunk.payload)
-                    const words = (chunk.meta.get("words") ?? []) as
-                        { word: string, start: Duration, end: Duration }[]
+                    /*  produce additional SRT/VTT blocks with each word highlighted  */
                     const occurrences = new Map<string, number>()
                     for (const word of words) {
                         let occurrence = occurrences.get(word.word) ?? 0
@@ -108,49 +121,210 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                         output += convertSingle(word.start, word.end, chunk.payload, word.word, occurrence)
                     }
                 }
-                else
-                    output += convertSingle(chunk.timestampStart, chunk.timestampEnd, chunk.payload)
                 return output
             }
 
             /*  establish a duplex stream  */
             const self = this
-            let firstChunk = true
+            let headerEmitted = false
             this.stream = new Stream.Transform({
                 readableObjectMode: true,
                 writableObjectMode: true,
                 decodeStrings:      false,
                 highWaterMark:      1,
                 transform (chunk: SpeechFlowChunk, encoding, callback) {
-                    if (firstChunk && self.params.format === "vtt") {
+                    if (!headerEmitted && self.params.format === "vtt") {
                         this.push(new SpeechFlowChunk(
                             Duration.fromMillis(0), Duration.fromMillis(0),
                             "final", "text",
                             "WEBVTT\n\n"
                         ))
-                        firstChunk = false
+                        headerEmitted = true
                     }
                     if (Buffer.isBuffer(chunk.payload))
                         callback(new Error("invalid chunk payload type"))
+                    else if (chunk.payload === "") {
+                        this.push(chunk)
+                        callback()
+                    }
                     else {
-                        if (chunk.payload === "") {
-                            this.push(chunk)
+                        convert(chunk).then((payload) => {
+                            const chunkNew = chunk.clone()
+                            chunkNew.payload = payload
+                            this.push(chunkNew)
                             callback()
+                        }).catch((error: unknown) => {
+                            callback(util.ensureError(error))
+                        })
+                    }
+                },
+                final (callback) {
+                    callback()
+                }
+            })
+        }
+        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})$/)
+                if (!match)
+                    throw new Error(`invalid timestamp format: "${ts}"`)
+                const hours        = Number.parseInt(match[1], 10)
+                const minutes      = Number.parseInt(match[2], 10)
+                const seconds      = Number.parseInt(match[3], 10)
+                const milliseconds = Number.parseInt(match[4], 10)
+                if (minutes > 59 || seconds > 59)
+                    throw new Error(`invalid timestamp value "${ts}"`)
+                return Duration.fromObject({ hours, minutes, seconds, milliseconds })
+            }
+
+            /*  strip arbitrary HTML tags  */
+            const stripHtmlTags = (text: string): string =>
+                text.replace(/<\/?[a-zA-Z][^>]*>/g, "")
+
+            /*  parse SRT format  */
+            const parseSRT = (input: string): TextChunk[] => {
+                const results: TextChunk[] = []
+
+                /*  iterate over all blocks  */
+                const blocks = input.trim().split(/\r?\n\r?\n+/)
+                for (const block of blocks) {
+                    const lines = block.trim().split(/\r?\n/)
+                    if (lines.length < 2) {
+                        this.log("warning", "SRT block contains less than 2 lines")
+                        continue
+                    }
+
+                    /*  skip optional sequence number line (first line)  */
+                    let lineIdx = 0
+                    if (/^\d+$/.test(lines[0].trim()))
+                        lineIdx = 1
+
+                    /*  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})/)
+                    if (!timeMatch) {
+                        this.log("warning", "SRT contains invalid timestamp line")
+                        continue
+                    }
+                    const start = parseTimestamp(timeMatch[1])
+                    const end   = parseTimestamp(timeMatch[2])
+
+                    /*  collect text lines  */
+                    const textLines = lines.slice(lineIdx + 1).join("\n")
+                    const text = stripHtmlTags(textLines).trim()
+                    if (text !== "")
+                        results.push({ start, end, text })
+                }
+                return results
+            }
+
+            /*  parse VTT format  */
+            const parseVTT = (input: string): TextChunk[] => {
+                const results: TextChunk[] = []
+
+                /*  remove VTT header and any metadata  */
+                const content = input.trim().replace(/^WEBVTT[^\r\n]*\r?\n*/, "")
+
+                /*  iterate over all blocks  */
+                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 less than 1 line")
+                        continue
+                    }
+
+                    /*  skip optional cue identifier lines  */
+                    let lineIdx = 0
+                    while (lineIdx < lines.length && !lines[lineIdx].includes("-->"))
+                        lineIdx++
+                    if (lineIdx >= lines.length)
+                        continue
+
+                    /*  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})/)
+                    if (!timeMatch) {
+                        this.log("warning", "VTT contains invalid timestamp line")
+                        continue
+                    }
+                    const start = parseTimestamp(timeMatch[1])
+                    const end   = parseTimestamp(timeMatch[2])
+
+                    /*  collect text lines  */
+                    const textLines = lines.slice(lineIdx + 1).join("\n")
+                    const text = stripHtmlTags(textLines).trim()
+                    if (text !== "")
+                        results.push({ start, end, text })
+                }
+                return results
+            }
+
+            /*  buffer for accumulating input  */
+            let buffer = ""
+
+            /*  establish a duplex stream  */
+            const self = this
+            this.stream = new Stream.Transform({
+                readableObjectMode: true,
+                writableObjectMode: true,
+                decodeStrings:      false,
+                highWaterMark:      1,
+                transform (chunk: SpeechFlowChunk, encoding, callback) {
+                    /*  sanity check text chunks  */
+                    if (Buffer.isBuffer(chunk.payload)) {
+                        callback(new Error("invalid chunk payload type"))
+                        return
+                    }
+
+                    /*  short-circuit processing in case of empty payloads  */
+                    if (chunk.payload === "") {
+                        this.push(chunk)
+                        callback()
+                        return
+                    }
+
+                    /*  accumulate input  */
+                    buffer += chunk.payload
+
+                    /*  parse accumulated input  */
+                    try {
+                        /*  parse entries  */
+                        const entries = (self.params.format === "srt" ? parseSRT(buffer) : parseVTT(buffer))
+
+                        /*  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)
                         }
-                        else {
-                            convert(chunk).then((payload) => {
-                                const chunkNew = chunk.clone()
-                                chunkNew.payload = payload
-                                this.push(chunkNew)
-                                callback()
-                            }).catch((error: unknown) => {
-                                callback(util.ensureError(error))
-                            })
-                        }
+
+                        /*  clear buffer after successful parse  */
+                        buffer = ""
+                        callback()
+                    }
+                    catch (error: unknown) {
+                        buffer = ""
+                        callback(util.ensureError(error))
                     }
                 },
                 final (callback) {
-                    this.push(null)
+                    /*  process any remaining buffer content  */
+                    if (buffer.trim() !== "") {
+                        try {
+                            /*  parse entries  */
+                            const entries = self.params.format === "srt" ? parseSRT(buffer) : parseVTT(buffer)
+
+                            /*  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)
+                            }
+                        }
+                        catch (_error: unknown) {
+                            /*  ignore parse errors on final flush  */
+                        }
+                    }
                     callback()
                 }
             })
@@ -239,13 +413,11 @@ export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
                 write (chunk: SpeechFlowChunk, encoding, callback) {
                     if (Buffer.isBuffer(chunk.payload))
                         callback(new Error("invalid chunk payload type"))
+                    else if (chunk.payload === "")
+                        callback()
                     else {
-                        if (chunk.payload === "")
-                            callback()
-                        else {
-                            emit(chunk)
-                            callback()
-                        }
+                        emit(chunk)
+                        callback()
                     }
                 },
                 final (callback) {

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

@@ -19,6 +19,9 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
     /*  cached regular expression instance  */
     private cachedRegExp = new util.CachedRegExp()
 
+    /*  internal state  */
+    private closing = false
+
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
         super(id, cfg, opts, args)
@@ -39,17 +42,20 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
+        /*  clear destruction flag  */
+        this.closing = false
+
         /*  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
+                const str1 = (typeof val1 === "string" ? val1 : val1.toString())
+                const str2 = (typeof val2 === "string" ? val2 : val2.toString())
                 return (op === "==" ? (str1 === str2) : (str1 !== str2))
             }
             else if (op === "~~" || op === "!~") {
                 /*  regular expression comparison  */
-                const str = (typeof val1 === "string" ? val1 : val1.toString()) as string
+                const str = (typeof val1 === "string" ? val1 : val1.toString())
                 const regexp = (
                     val2 instanceof RegExp ?
                         val2 :
@@ -93,6 +99,10 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
             decodeStrings:      false,
             highWaterMark:      1,
             transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (self.closing) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
                 let val1: any
                 const val2: any = self.params.val
                 const m = self.params.var.match(/^meta:(.+)$/)
@@ -117,7 +127,6 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
                 callback()
             },
             final (callback) {
-                this.push(null)
                 callback()
             }
         })
@@ -125,6 +134,9 @@ export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
+        /*  indicate closing  */
+        this.closing = true
+
         /*  shutdown stream  */
         if (this.stream !== null) {
             await util.destroyStream(this.stream)

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

@@ -28,10 +28,10 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            type:      { type: "string", pos: 0, val: "audio", match: /^(?:audio|text)$/ },
-            name:      { type: "string", pos: 1, val: "trace" },
+            type:      { type: "string", pos: 0, val: "audio",  match: /^(?:audio|text)$/  },
+            name:      { type: "string", pos: 1, val: "trace"                              },
             mode:      { type: "string", pos: 2, val: "filter", match: /^(?:filter|sink)$/ },
-            dashboard: { type: "string",         val: "" }
+            dashboard: { type: "string",         val: ""                                   }
         })
 
         /*  sanity check parameters  */
@@ -119,11 +119,6 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.closing || self.params.mode === "sink") {
-                    callback()
-                    return
-                }
-                this.push(null)
                 callback()
             }
         })

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

@@ -20,10 +20,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
     public static name = "xio-device"
 
     /*  internal state  */
-    private io: PortAudio.IoStreamRead
-        | PortAudio.IoStreamWrite
-        | PortAudio.IoStreamDuplex
-        | null = null
+    private io: PortAudio.IoStreamRead | PortAudio.IoStreamWrite | PortAudio.IoStreamDuplex | null = null
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -87,7 +84,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         return device
     }
 
-    /*  NOTICE: "naudion" actually implements Stream.{Readable,Writable,Duplex}, but
+    /*  NOTICE: "naudiodon" actually implements Stream.{Readable,Writable,Duplex}, but
         declares just its sub-interface NodeJS.{Readable,Writable,Duplex}Stream,
         so it is correct to cast it back to Stream.{Readable,Writable,Duplex}
         in the following device stream setup functions!  */
@@ -118,7 +115,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         this.stream = this.io as unknown as Stream.Duplex
 
         /*  convert regular stream into object-mode stream  */
-        const wrapper1 = util.createTransformStreamForWritableSide()
+        const wrapper1 = util.createTransformStreamForWritableSide("audio", 1)
         const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero, highwaterMark)
         this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
     }
@@ -161,7 +158,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         this.stream = this.io as unknown as Stream.Writable
 
         /*  convert regular stream into object-mode stream  */
-        const wrapper = util.createTransformStreamForWritableSide()
+        const wrapper = util.createTransformStreamForWritableSide("audio", 1)
         this.stream = Stream.compose(wrapper, this.stream)
     }
 
@@ -211,7 +208,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
                     throw error
             }
             await Promise.race([
-                util.timeoutPromise(2 * 1000, "PortAudio abort timeout"),
+                util.timeout(2 * 1000, "PortAudio abort timeout"),
                 new Promise<void>((resolve) => {
                     this.io!.abort(() => {
                         resolve()
@@ -219,7 +216,7 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
                 }).catch(catchHandler)
             ])
             await Promise.race([
-                util.timeoutPromise(2 * 1000, "PortAudio quit timeout"),
+                util.timeout(2 * 1000, "PortAudio quit timeout"),
                 new Promise<void>((resolve) => {
                     this.io!.quit(() => {
                         resolve()

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

@@ -128,7 +128,7 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
             }
 
             /*  convert regular stream into object-mode stream  */
-            const wrapper1 = util.createTransformStreamForWritableSide()
+            const wrapper1 = util.createTransformStreamForWritableSide(this.params.type, 1)
             const wrapper2 = util.createTransformStreamForReadableSide(
                 this.params.type, () => this.timeZero)
             this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
@@ -171,7 +171,7 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
                 else
                     process.stdout.setEncoding(this.config.textEncoding)
                 const chunker = createStdoutChunker()
-                const wrapper = util.createTransformStreamForWritableSide()
+                const wrapper = util.createTransformStreamForWritableSide(this.params.type, 1)
                 this.stream = Stream.compose(wrapper, chunker)
             }
             else {
@@ -183,7 +183,7 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
                 else
                     writable = fs.createWriteStream(this.params.path,
                         { highWaterMark: highWaterMarkText, encoding: this.config.textEncoding })
-                const wrapper = util.createTransformStreamForWritableSide()
+                const wrapper = util.createTransformStreamForWritableSide(this.params.type, 1)
                 this.stream = Stream.compose(wrapper, writable)
             }
         }
@@ -210,7 +210,7 @@ export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
                                 else     resolve()
                             })
                         }),
-                        util.timeoutPromise(5000)
+                        util.timeout(5000)
                     ])
                 }
             }

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

@@ -97,7 +97,8 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
             this.log("info", `connection re-opened to MQTT ${this.params.url}`)
         })
         this.broker.on("disconnect", (packet: MQTT.IDisconnectPacket) => {
-            this.log("info", `connection closed to MQTT ${this.params.url}`)
+            const reasonCode = packet.reasonCode ?? 0
+            this.log("info", `connection closed to MQTT ${this.params.url} (reason code: ${reasonCode})`)
         })
         this.chunkQueue = new util.SingleQueue<SpeechFlowChunk>()
         this.broker.on("message", (topic: string, payload: Buffer, packet: MQTT.IPublishPacket) => {
@@ -107,11 +108,12 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
                 const chunk = util.streamChunkDecode(payload)
                 this.chunkQueue!.write(chunk)
             }
-            catch (_err: any) {
+            catch (_err: unknown) {
                 this.log("warning", `received invalid CBOR chunk from MQTT ${this.params.url}`)
             }
         })
         const self = this
+        const reads = new util.PromiseSet<void>()
         this.stream = new Stream.Duplex({
             writableObjectMode: true,
             readableObjectMode: true,
@@ -134,14 +136,18 @@ export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
                     })
                 }
             },
+            async final (callback) {
+                await reads.awaitAll()
+                callback()
+            },
             read (size: number) {
                 if (self.params.mode === "w")
                     throw new Error("read operation on write-only node")
-                self.chunkQueue!.read().then((chunk) => {
+                reads.add(self.chunkQueue!.read().then((chunk) => {
                     this.push(chunk, "binary")
                 }).catch((err: Error) => {
                     self.log("warning", `read on chunk queue operation failed: ${err}`)
-                })
+                }))
             }
         })
     }

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

@@ -109,6 +109,7 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
                 this.log("error", `error of some connection on URL ${this.params.listen}: ${error.message}`)
             })
             const self = this
+            const reads = new util.PromiseSet<void>()
             this.stream = new Stream.Duplex({
                 writableObjectMode: true,
                 readableObjectMode: true,
@@ -141,14 +142,18 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
                         })
                     }
                 },
+                async final (callback) {
+                    await reads.awaitAll()
+                    callback()
+                },
                 read (size: number) {
                     if (self.params.mode === "w")
                         throw new Error("read operation on write-only node")
-                    chunkQueue.read().then((chunk) => {
+                    reads.add(chunkQueue.read().then((chunk) => {
                         this.push(chunk, "binary")
                     }).catch((err: Error) => {
                         self.log("warning", `read on chunk queue operation failed: ${err}`)
-                    })
+                    }))
                 }
             })
         }
@@ -170,7 +175,8 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
                 this.log("info", `connection closed to URL ${this.params.connect}`)
             })
             this.client.addEventListener("error", (ev: ErrorEvent) => {
-                this.log("error", `error of connection on URL ${this.params.connect}: ${ev.error.message}`)
+                const error = util.ensureError(ev.error)
+                this.log("error", `error of connection on URL ${this.params.connect}: ${error.message}`)
             })
             const chunkQueue = new util.SingleQueue<SpeechFlowChunk>()
             this.client.addEventListener("message", (ev: MessageEvent) => {
@@ -190,6 +196,7 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
             })
             this.client.binaryType = "arraybuffer"
             const self = this
+            const reads = new util.PromiseSet<void>()
             this.stream = new Stream.Duplex({
                 writableObjectMode: true,
                 readableObjectMode: true,
@@ -208,14 +215,18 @@ export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
                         callback()
                     }
                 },
+                async final (callback) {
+                    await reads.awaitAll()
+                    callback()
+                },
                 read (size: number) {
                     if (self.params.mode === "w")
                         throw new Error("read operation on write-only node")
-                    chunkQueue.read().then((chunk) => {
+                    reads.add(chunkQueue.read().then((chunk) => {
                         this.push(chunk, "binary")
                     }).catch((err: Error) => {
                         self.log("warning", `read on chunk queue operation failed: ${err}`)
-                    })
+                    }))
                 }
             })
         }

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

@@ -38,7 +38,7 @@ class AudioSourceProcessor extends AudioWorkletProcessor {
     private currentOffset = 0
 
     /*  node construction  */
-    constructor() {
+    constructor () {
         super()
 
         /*  receive input chunks  */
@@ -50,7 +50,7 @@ class AudioSourceProcessor extends AudioWorkletProcessor {
     }
 
     /*  process audio frame  */
-    process(
+    process (
         inputs:     Float32Array[][],            /* unused */
         outputs:    Float32Array[][],
         parameters: Record<string, Float32Array> /* unused */
@@ -117,7 +117,7 @@ class AudioCaptureProcessor extends AudioWorkletProcessor {
     private activeCaptures = new Map<string, { data: number[], expectedSamples: number }>()
 
     /*  node construction  */
-    constructor() {
+    constructor () {
         super()
 
         /*  receive start of capturing command  */
@@ -133,7 +133,7 @@ class AudioCaptureProcessor extends AudioWorkletProcessor {
     }
 
     /*  process audio frame  */
-    process(
+    process (
         inputs:     Float32Array[][],
         outputs:    Float32Array[][],             /* unused */
         parameters: Record<string, Float32Array>  /* unused */