speechflow 2.2.1 → 2.3.1

package/speechflow-cli/src/speechflow-main-api.ts

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -37,6 +37,7 @@ export class APIServer {
     private wsPeers                                                 = new Map<string, WSPeerInfo>()
     private hapi:    HAPI.Server                             | null = null
     private sendOSC: ((url: string, ...args: any[]) => void) | null = null
+    private graph:   NodeGraph                                | null = null
 
     /*  creation  */
     constructor (
@@ -45,6 +46,9 @@ export class APIServer {
 
     /*  start API server service  */
     async start (args: CLIOptions, graph: NodeGraph): Promise<void> {
+        /*  remember graph for later cleanup  */
+        this.graph = graph
+
         /*  define external request/response structure  */
         const requestValidator = arktype.type({
             request: "string",
@@ -67,10 +71,13 @@ export class APIServer {
                 throw new Error(`external request failed: no such node <${name}>`)
             }
             else {
+                const ac = new AbortController()
                 await Promise.race([
                     foundNode.receiveRequest(argList),
-                    util.timeout(10 * 1000)
-                ]).catch((err: Error) => {
+                    util.timeout(10 * 1000, "timeout", ac.signal)
+                ]).finally(() => {
+                    ac.abort()
+                }).catch((err: Error) => {
                     this.cli.log("warning", `external request to node <${name}> failed: ${err.message}`)
                     throw err
                 })
@@ -133,9 +140,14 @@ export class APIServer {
             method: "GET",
             path:   "/api/dashboard",
             handler: (request: HAPI.Request, h: HAPI.ResponseToolkit) => {
-                const config = []
+                const config: { type: string, id: string, name: string }[] = []
+                if (args.d === "")
+                    return h.response(config).code(200)
                 for (const block of args.d.split(",")) {
-                    const [ type, id, name ] = block.split(":")
+                    const parts = block.split(":")
+                    if (parts.length !== 3)
+                        continue
+                    const [ type, id, name ] = parts
                     config.push({ type, id, name })
                 }
                 return h.response(config).code(200)
@@ -215,7 +227,10 @@ export class APIServer {
                 for (const [ peer, info ] of this.wsPeers.entries()) {
                     this.cli.log("debug", `HAPI: remote peer ${peer}: sending ${data}`)
                     if (info.ws.readyState === WebSocket.OPEN)
-                        info.ws.send(data)
+                        info.ws.send(data, (err) => {
+                            if (err)
+                                this.cli.log("warning", `HAPI: peer ${peer}: send failed: ${err.message}`)
+                        })
                 }
             })
         }
@@ -230,13 +245,18 @@ export class APIServer {
             const port = Number.parseInt(m[2], 10)
             this.sendOSC = (url: string, ...argList: any[]) => {
                 const msg = new OSC.Message(url, ...argList)
-                osc.send(msg, { host, port })
+                try {
+                    osc.send(msg, { host, port })
+                }
+                catch (err: any) {
+                    this.cli.log("warning", `OSC/UDP send to ${host}:${port} failed: ${err.message}`)
+                }
             }
         }
 
         /*  hook for send-dashboard method of nodes  */
         for (const node of graph.getGraphNodes()) {
-            node.on("send-dashboard", (info: {
+            node.on("send-dashboard", async (info: {
                 type: "audio" | "text",
                 id:   string,
                 kind: "final" | "intermediate",
@@ -250,16 +270,26 @@ export class APIServer {
                 for (const [ peer, peerInfo ] of this.wsPeers.entries()) {
                     this.cli.log("debug", `HAPI: dashboard peer ${peer}: send ${data}`)
                     if (peerInfo.ws.readyState === WebSocket.OPEN)
-                        peerInfo.ws.send(data)
+                        peerInfo.ws.send(data, (err) => {
+                            if (err)
+                                this.cli.log("warning", `HAPI: dashboard peer ${peer}: send failed: ${err.message}`)
+                        })
                 }
+                const promises: Promise<void>[] = []
                 for (const n of graph.getGraphNodes()) {
-                    Promise.race([
-                        n.receiveDashboard(info.type, info.id, info.kind, info.value),
-                        util.timeout(10 * 1000)
-                    ]).catch((err: Error) => {
-                        this.cli.log("warning", `sending dashboard info to node <${n.id}> failed: ${err.message}`)
-                    })
+                    const ac = new AbortController()
+                    promises.push(
+                        Promise.race([
+                            n.receiveDashboard(info.type, info.id, info.kind, info.value),
+                            util.timeout(10 * 1000, "timeout", ac.signal)
+                        ]).finally(() => {
+                            ac.abort()
+                        }).catch((err: Error) => {
+                            this.cli.log("warning", `sending dashboard info to node <${n.id}> failed: ${err.message}`)
+                        })
+                    )
                 }
+                await Promise.allSettled(promises)
                 if (args.o !== "" && this.sendOSC)
                     this.sendOSC("/speechflow/dashboard", info.type, info.id, info.kind, info.value)
             })
@@ -268,6 +298,15 @@ export class APIServer {
 
     /*  stop API server service  */
     async stop (args: CLIOptions): Promise<void> {
+        /*  remove event listeners from graph nodes  */
+        if (this.graph) {
+            for (const node of this.graph.getGraphNodes()) {
+                node.removeAllListeners("send-response")
+                node.removeAllListeners("send-dashboard")
+            }
+            this.graph = null
+        }
+
         /*  shutdown HAPI service  */
         if (this.hapi) {
             this.cli.log("info", `HAPI: stopping REST/WebSocket network service: http://${args.a}:${args.p}`)
@@ -294,10 +333,13 @@ export class APIServer {
                     }
                 }))
             }
+            const ac = new AbortController()
             await Promise.race([
                 Promise.all(closePromises),
-                util.timeout(5 * 1000)
-            ]).catch((error: unknown) => {
+                util.timeout(5 * 1000, "timeout", ac.signal)
+            ]).finally(() => {
+                ac.abort()
+            }).catch((error: unknown) => {
                 this.cli.log("warning", `HAPI: WebSockets failed to close: ${util.ensureError(error).message}`)
             })
             this.wsPeers.clear()
@@ -305,7 +347,7 @@ export class APIServer {
     }
 
     /*  send information to dashboard on error  */
-    async sendErrorToDashboard (time: number, node: string, level: string, message: string): Promise<void> {
+    sendErrorToDashboard (time: number, node: string, level: string, message: string) {
         const data = JSON.stringify({
             response: "HINT",
             node,
@@ -314,7 +356,10 @@ export class APIServer {
         for (const [ peer, peerInfo ] of this.wsPeers.entries()) {
             this.cli.log("debug", `HAPI: dashboard peer ${peer}: send ${data}`)
             if (peerInfo.ws.readyState === WebSocket.OPEN)
-                peerInfo.ws.send(data)
+                peerInfo.ws.send(data, (err) => {
+                    if (err)
+                        this.cli.log("warning", `HAPI: dashboard peer ${peer}: send failed: ${err.message}`)
+                })
         }
     }
 }

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -185,7 +185,7 @@ export class CLIContext {
         if (this.args.V) {
             process.stderr.write(`SpeechFlow ${pkg["x-stdver"]} (${pkg["x-release"]}) <${pkg.homepage}>\n`)
             process.stderr.write(`${pkg.description}\n`)
-            process.stderr.write(`Copyright (c) 2024-2025 ${pkg.author.name} <${pkg.author.url}>\n`)
+            process.stderr.write(`Copyright (c) 2024-2026 ${pkg.author.name} <${pkg.author.url}>\n`)
             process.stderr.write(`Licensed under ${pkg.license} <http://spdx.org/licenses/${pkg.license}.html>\n`)
             process.exit(0)
         }

package/speechflow-cli/src/speechflow-main-config.ts

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

package/speechflow-cli/src/speechflow-main-graph.ts

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -171,10 +171,13 @@ export class NodeGraph {
             /*  open node  */
             this.cli.log("info", `open node <${node.id}>`)
             node.setTimeZero(this.timeZero)
+            const ac = new AbortController()
             await Promise.race([
                 node.open(),
-                util.timeout(30 * 1000)
-            ]).catch((err: Error) => {
+                util.timeout(30 * 1000, "timeout", ac.signal)
+            ]).finally(() => {
+                ac.abort()
+            }).catch((err: Error) => {
                 this.cli.log("error", `<${node.id}>: failed to open node <${node.id}>: ${err.message}`)
                 throw new Error(`failed to open node <${node.id}>: ${err.message}`)
             })
@@ -211,8 +214,9 @@ export class NodeGraph {
             this.cli.log("info", `observe stream of node <${node.id}> for finish event`)
             this.activeNodes.add(node)
             const deactivateNode = (node: SpeechFlowNode, msg: string) => {
-                if (this.activeNodes.has(node))
-                    this.activeNodes.delete(node)
+                if (!this.activeNodes.has(node))
+                    return
+                this.activeNodes.delete(node)
                 this.cli.log("info", `${msg} (${this.activeNodes.size} active nodes remaining)`)
                 if (this.activeNodes.size === 0) {
                     const timeFinished = DateTime.now()
@@ -220,7 +224,9 @@ export class NodeGraph {
                     this.cli.log("info", "**** everything finished -- stream processing in SpeechFlow graph stops " +
                         `(total duration: ${duration?.toFormat("hh:mm:ss.SSS") ?? "unknown"}) ****`)
                     this.finishEvents.emit("finished")
-                    this.shutdown("finished", args, api)
+                    this.shutdown("finished", args, api).catch((err: Error) => {
+                        this.cli.log("error", `failed to shutdown: ${err.message}`)
+                    })
                 }
             }
             node.stream.on("error", (err: unknown) => {
@@ -228,12 +234,26 @@ export class NodeGraph {
                 this.cli.log("warning", `stream of node <${node.id}> raised "error" event: ${error.message}`)
                 api.sendErrorToDashboard(Date.now(), node.id, "warning", error.message)
             })
-            node.stream.on("finish", () => {
-                deactivateNode(node, `writable stream side (input) of node <${node.id}> raised "finish" event`)
-            })
-            node.stream.on("end", () => {
-                deactivateNode(node, `readable stream side (output) of node <${node.id}> raised "end" event`)
-            })
+
+            /*  listen for the semantically correct completion event per stream type:
+                - for Duplex/Transform listen only for "end"
+                  (readable-side, fires last, guarantees all output is drained),
+                - for pure Readable listen only for "end"
+                - for pure Writable listen only for "finish"  */
+            if (node.stream instanceof Stream.Duplex)
+                node.stream.on("end", () => {
+                    deactivateNode(node, `readable stream side (output) of node <${node.id}> raised "end" event`)
+                })
+            else if (node.stream instanceof Stream.Readable)
+                node.stream.on("end", () => {
+                    deactivateNode(node, `readable stream side (output) of node <${node.id}> raised "end" event`)
+                })
+            else if (node.stream instanceof Stream.Writable)
+                node.stream.on("finish", () => {
+                    deactivateNode(node, `writable stream side (input) of node <${node.id}> raised "finish" event`)
+                })
+            else
+                throw new Error(`stream of node <${node.id}> is neither of Duplex, Writable, nor Readable type`)
         }
 
         /*  start of internal stream processing  */
@@ -250,13 +270,16 @@ export class NodeGraph {
             const stream = node.stream
             if ((stream instanceof Stream.Writable || stream instanceof Stream.Duplex)
                 && (!stream.writableEnded && !stream.destroyed)) {
+                const ac = new AbortController()
                 drainPromises.push(
                     Promise.race([
                         new Promise<void>((resolve) => {
                             stream.end(() => { resolve() })
                         }),
-                        util.timeout(5000)
-                    ]).catch(() => {
+                        util.timeout(5000, "timeout", ac.signal)
+                    ]).finally(() => {
+                        ac.abort()
+                    }).catch(() => {
                         /*  ignore timeout -- stream will be destroyed later  */
                     })
                 )
@@ -297,10 +320,13 @@ export class NodeGraph {
     async closeNodes (): Promise<void> {
         for (const node of this.graphNodes) {
             this.cli.log("info", `close node <${node.id}>`)
+            const ac = new AbortController()
             await Promise.race([
                 node.close(),
-                util.timeout(10 * 1000)
-            ]).catch((err: Error) => {
+                util.timeout(10 * 1000, "timeout", ac.signal)
+            ]).finally(() => {
+                ac.abort()
+            }).catch((err: Error) => {
                 this.cli.log("warning", `node <${node.id}> failed to close: ${err.message}`)
             })
         }
@@ -319,25 +345,33 @@ export class NodeGraph {
 
     /*  graph destruction: PASS 5: destroy nodes  */
     destroyNodes (): void {
-        for (const node of this.graphNodes) {
+        for (const node of this.graphNodes)
             this.cli.log("info", `destroy node <${node.id}>`)
-            this.graphNodes.delete(node)
-        }
+        this.graphNodes.clear()
     }
 
     /*  setup signal handling for shutdown  */
     setupSignalHandlers (args: CLIOptions, api: APIServer): void {
         /*  internal helper functions  */
-        const shutdownHandler = (signal: string) =>
-            this.shutdown(signal, args, api)
         const logError = (error: Error) => {
             if (this.debug)
                 this.cli.log("error", `${error.message}\n${error.stack}`)
             else
                 this.cli.log("error", error.message)
         }
+        const shutdownHandler = (signal: string) => {
+            this.shutdown(signal, args, api).catch((err: unknown) => {
+                const error = util.ensureError(err, "shutdown error")
+                logError(error)
+                process.exit(1)
+            })
+        }
 
-        /*  hook into process signals  */
+        /*  re-hook into process signals  */
+        process.removeAllListeners("SIGINT")
+        process.removeAllListeners("SIGUSR1")
+        process.removeAllListeners("SIGUSR2")
+        process.removeAllListeners("SIGTERM")
         process.on("SIGINT",  () => { shutdownHandler("SIGINT")   })
         process.on("SIGUSR1", () => { shutdownHandler("SIGUSR1")  })
         process.on("SIGUSR2", () => { shutdownHandler("SIGUSR2")  })

package/speechflow-cli/src/speechflow-main-nodes.ts

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

package/speechflow-cli/src/speechflow-main-status.ts

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -47,10 +47,13 @@ export class NodeStatusManager {
             this.cli.log("info", `gathering status of node <${name}>`)
             const node = new nodes[name](name, cfg, {}, [])
             node._accessBus = accessBus
+            const ac = new AbortController()
             const status = await Promise.race<{ [ key: string ]: string | number }>([
                 node.status(),
-                util.timeout(10 * 1000)
-            ]).catch((err: Error) => {
+                util.timeout(10 * 1000, "timeout", ac.signal)
+            ]).finally(() => {
+                ac.abort()
+            }).catch((err: Error) => {
                 this.cli.log("warning", `[${node.id}]: failed to gather status of node <${node.id}>: ${err.message}`)
                 return {} as { [ key: string ]: string | number }
             })

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

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

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -21,8 +21,7 @@ class CompressorProcessor extends AudioWorkletProcessor {
             { name: "ratio",      defaultValue: 4.0,   minValue: 1.0,    maxValue: 20,  automationRate: "k-rate" }, // compression ratio
             { name: "attack",     defaultValue: 0.010, minValue: 0.0,    maxValue: 1,   automationRate: "k-rate" }, // seconds
             { name: "release",    defaultValue: 0.050, minValue: 0.0,    maxValue: 1,   automationRate: "k-rate" }, // seconds
-            { name: "knee",       defaultValue: 6.0,   minValue: 0.0,    maxValue: 40,  automationRate: "k-rate" }, // dB
-            { name: "makeup",     defaultValue: 0.0,   minValue: -24,    maxValue: 24,  automationRate: "k-rate" }  // dB
+            { name: "knee",       defaultValue: 6.0,   minValue: 0.0,    maxValue: 40,  automationRate: "k-rate" }  // dB
         ]
     }
 
@@ -39,20 +38,19 @@ class CompressorProcessor extends AudioWorkletProcessor {
         if (ratio <= 1.0)
             return 0
 
-        /*  determine thresholds  */
+        /*  determine knee boundaries (symmetric around threshold)  */
         const halfKnee  = kneeDB * 0.5
-        const belowThr  = levelDB < thresholdDB
-        const aboveKnee = levelDB >= (thresholdDB + halfKnee)
+        const belowKnee = levelDB < (thresholdDB - halfKnee)
+        const aboveKnee = levelDB > (thresholdDB + halfKnee)
 
-        /*  short-circuit for no compression (below threshold)  */
-        if (belowThr)
+        /*  short-circuit for no compression (below knee)  */
+        if (belowKnee)
             return 0
 
-        /*  apply soft-knee  */
+        /*  apply soft-knee (standard textbook quadratic)  */
         if (kneeDB > 0 && !aboveKnee) {
-            const x = (levelDB - thresholdDB) / kneeDB
-            const idealGainDB = (thresholdDB + (levelDB - thresholdDB) / ratio) - levelDB
-            return idealGainDB * x * x
+            const d = levelDB - thresholdDB + halfKnee
+            return (1.0 / ratio - 1.0) * d * d / (2.0 * kneeDB)
         }
 
         /*  determine target level  */
@@ -94,21 +92,18 @@ class CompressorProcessor extends AudioWorkletProcessor {
         const kneeDB      = parameters["knee"][0]
         const attackS     = Math.max(parameters["attack"][0],  1 / this.sampleRate)
         const releaseS    = Math.max(parameters["release"][0], 1 / this.sampleRate)
-        const makeupDB    = parameters["makeup"][0]
 
-        /*  update envelope per channel  */
+        /*  update envelope per channel and collect RMS values  */
+        const rms = Array.from<number>({ length: nCh })
         for (let ch = 0; ch < nCh; ch++)
-            this.env[ch] = util.updateEnvelopeForChannel(this.env, this.sampleRate, ch, input[ch], attackS, releaseS)
-
-        /*  determine linear value from decibel makeup value */
-        const makeUpLin = util.dB2lin(makeupDB)
+            rms[ch] = util.updateEnvelopeForChannel(this.env, this.sampleRate, ch, input[ch], attackS, releaseS)
 
         /*  iterate over all channels  */
         this.reduction = 0
         for (let ch = 0; ch < nCh; ch++) {
-            const levelDB = util.lin2dB(this.env[ch])
+            const levelDB = util.lin2dB(rms[ch])
             const gainDB  = this.gainDBFor(levelDB, thresholdDB, ratio, kneeDB)
-            const gainLin = util.dB2lin(gainDB) * makeUpLin
+            const gainLin = util.dB2lin(gainDB)
 
             /*  on first channel, calculate reduction  */
             if (ch === 0)
@@ -120,6 +115,10 @@ class CompressorProcessor extends AudioWorkletProcessor {
             for (let i = 0; i < inp.length; i++)
                 out[i] = inp[i] * gainLin
         }
+
+        /*  report reduction to main thread  */
+        this.port.postMessage({ type: "reduction", reduction: this.reduction })
+
         return true
     }
 }

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

@@ -1,6 +1,6 @@
 /*
 **  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Copyright (c) 2024-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
@@ -29,11 +29,13 @@ interface AudioCompressorConfig {
 /*  audio compressor class  */
 class AudioCompressor extends util.WebAudio {
     /*  internal state  */
-    private type:              "standalone" | "sidechain"
-    private mode:              "compress" | "measure" | "adjust"
-    private config:            Required<AudioCompressorConfig>
-    private compressorNode:    AudioWorkletNode | null = null
-    private gainNode:          GainNode | null = null
+    private type:               "standalone" | "sidechain"
+    private mode:               "compress" | "measure" | "adjust"
+    private config:             Required<AudioCompressorConfig>
+    private compressorNode:     AudioWorkletNode | null = null
+    private gainNode:           GainNode | null = null
+    private _reduction          = 0
+    private _reductionListener: ((event: MessageEvent) => void) | null = null
 
     /*  construct object  */
     constructor (
@@ -85,6 +87,16 @@ class AudioCompressor extends util.WebAudio {
             })
         }
 
+        /*  listen for reduction updates from compressor worklet  */
+        if (needsCompressor) {
+            this._reductionListener = (event: MessageEvent) => {
+                if (event.data?.type === "reduction")
+                    this._reduction = event.data.reduction
+            }
+            this.compressorNode!.port.addEventListener("message", this._reductionListener)
+            this.compressorNode!.port.start()
+        }
+
         /*  create gain node  */
         if (needsGain)
             this.gainNode = this.audioContext.createGain()
@@ -97,6 +109,7 @@ class AudioCompressor extends util.WebAudio {
         }
         else if (this.type === "sidechain" && this.mode === "measure") {
             this.sourceNode!.connect(this.compressorNode!)
+            this.compressorNode!.connect(this.captureNode!)
         }
         else if (this.type === "sidechain" && this.mode === "adjust") {
             this.sourceNode!.connect(this.gainNode!)
@@ -112,7 +125,6 @@ class AudioCompressor extends util.WebAudio {
             params.get("attack")!.setValueAtTime(this.config.attackMs / 1000, currentTime)
             params.get("release")!.setValueAtTime(this.config.releaseMs / 1000, currentTime)
             params.get("knee")!.setValueAtTime(this.config.kneeDb, currentTime)
-            params.get("makeup")!.setValueAtTime(this.config.makeupDb, currentTime)
         }
 
         /*  configure gain node  */
@@ -124,8 +136,7 @@ class AudioCompressor extends util.WebAudio {
 
     /*  get the current gain reduction  */
     public getGainReduction (): number {
-        const processor = (this.compressorNode as any)?.port?.processor
-        return processor?.reduction ?? 0
+        return this._reduction
     }
 
     /*  set the current gain  */
@@ -138,6 +149,10 @@ class AudioCompressor extends util.WebAudio {
     public async destroy (): Promise<void> {
         /*  destroy nodes  */
         if (this.compressorNode !== null) {
+            if (this._reductionListener !== null) {
+                this.compressorNode.port.removeEventListener("message", this._reductionListener)
+                this._reductionListener = null
+            }
             this.compressorNode.disconnect()
             this.compressorNode = null
         }
@@ -244,7 +259,7 @@ export default class SpeechFlowNodeA2ACompressor extends SpeechFlowNode {
                     callback(new Error("compressor not initialized"))
                 else {
                     /*  compress chunk  */
-                    const payload = util.convertBufToI16(chunk.payload)
+                    const payload = util.convertBufToI16(chunk.payload, self.config.audioLittleEndian)
                     self.compressor.process(payload).then((result) => {
                         if (self.closing) {
                             callback(new Error("stream already destroyed"))
@@ -253,10 +268,13 @@ export default class SpeechFlowNodeA2ACompressor extends SpeechFlowNode {
                         if ((self.params.type === "standalone" && self.params.mode === "compress")
                             || (self.params.type === "sidechain"  && self.params.mode === "adjust")) {
                             /*  take over compressed data  */
-                            const payload = util.convertI16ToBuf(result)
-                            chunk.payload = payload
+                            const payload = util.convertI16ToBuf(result, self.config.audioLittleEndian)
+                            const chunkNew = chunk.clone()
+                            chunkNew.payload = payload
+                            this.push(chunkNew)
                         }
-                        this.push(chunk)
+                        else
+                            this.push(chunk)
                         callback()
                     }).catch((error: unknown) => {
                         if (self.closing)