speechflow 1.6.4 → 1.6.6

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

@@ -22,9 +22,9 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
     /*  internal state  */
     private emitInterval: ReturnType<typeof setInterval> | null = null
     private calcInterval: ReturnType<typeof setInterval> | null = null
-    private silenceTimer: ReturnType<typeof setTimeout> | null = null
+    private silenceTimer: ReturnType<typeof setTimeout>  | null = null
     private chunkBuffer = new Float32Array(0)
-    private destroyed = false
+    private closing = false
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -32,7 +32,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            interval:  { type: "number", pos: 0, val: 250 },
+            interval:  { type: "number", pos: 0, val: 100 },
             mode:      { type: "string", pos: 1, val: "filter", match: /^(?:filter|sink)$/ },
             dashboard: { type: "string",         val: "" }
         })
@@ -52,74 +52,94 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
             throw new Error("meter node currently supports PCM-S16LE audio only")
 
         /*  clear destruction flag  */
-        this.destroyed = false
+        this.closing = false
 
         /*  internal state  */
-        const sampleWindowDuration = 3 /* LUFS-S requires 3s */
+        let lufsm = -60
+        let rms   = -60
+
+        /*  chunk processing state for LUFS-M  */
+        const sampleWindowDuration = 0.4 /* LUFS-M requires 400ms */
         const sampleWindowSize = Math.floor(this.config.audioSampleRate * sampleWindowDuration)
         const sampleWindow = new Float32Array(sampleWindowSize)
         sampleWindow.fill(0, 0, sampleWindowSize)
-        let lufss = -60
-        let rms   = -60
 
-        /*  chunk processing state  */
+        /*  chunk processing state for RMS  */
         const chunkDuration = 0.050 /* meter update frequency is about 50ms */
         const samplesPerChunk = Math.floor(this.config.audioSampleRate * chunkDuration)
         this.chunkBuffer = new Float32Array(0)
 
-        /*  define chunk processing function  */
-        const processChunk = (chunkData: Float32Array) => {
-            /*  update internal audio sample sliding window  */
-            sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
-            sampleWindow.set(chunkData, sampleWindowSize - chunkData.length)
+        /*  setup chunking interval  */
+        this.calcInterval = setInterval(() => {
+            /*  short-circuit during destruction  */
+            if (this.closing)
+                return
 
-            /*  calculate the LUFS-S and RMS metric  */
-            const audioData = {
+            /*  short-circuit if still not enough chunk data  */
+            if (this.chunkBuffer.length < samplesPerChunk)
+                return
+
+            /*  grab the accumulated chunk data  */
+            const chunkData = this.chunkBuffer
+            this.chunkBuffer = new Float32Array(0)
+
+            /*  update internal audio sample sliding window for LUFS-S  */
+            if (chunkData.length > sampleWindow.length)
+                sampleWindow.set(chunkData.subarray(chunkData.length - sampleWindow.length), 0)
+            else {
+                sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
+                sampleWindow.set(chunkData, sampleWindow.length - chunkData.length)
+            }
+
+            /*  calculate the LUFS-M metric  */
+            const audioDataLUFS = {
                 sampleRate:       this.config.audioSampleRate,
                 numberOfChannels: this.config.audioChannels,
                 channelData:      [ sampleWindow ],
                 duration:         sampleWindowDuration,
                 length:           sampleWindow.length
             } satisfies AudioData
-            const lufs = getLUFS(audioData, {
+            const lufs = getLUFS(audioDataLUFS, {
                 channelMode: this.config.audioChannels === 1 ? "mono" : "stereo",
-                calculateShortTerm:     true,
-                calculateMomentary:     false,
+                calculateShortTerm:     false,
+                calculateMomentary:     true,
                 calculateLoudnessRange: false,
                 calculateTruePeak:      false
             })
-            lufss = lufs.shortTerm ? lufs.shortTerm[0] : -60
-            rms = getRMS(audioData, { asDB: true })
+            lufsm = lufs.momentary ? Math.max(-60, lufs.momentary[0]) : -60
+
+            /*  calculate the RMS metric  */
+            const totalSamples   = chunkData.length / this.config.audioChannels
+            const duration       = totalSamples / this.config.audioSampleRate
+            const audioDataRMS = {
+                sampleRate:       this.config.audioSampleRate,
+                numberOfChannels: this.config.audioChannels,
+                channelData:      [ chunkData ],
+                duration,
+                length:           chunkData.length
+            } satisfies AudioData
+            rms = Math.max(-60, getRMS(audioDataRMS, {
+                asDB: true
+            }))
+
+            /*  automatically clear measurement (in case no new measurements happen)  */
             if (this.silenceTimer !== null)
                 clearTimeout(this.silenceTimer)
             this.silenceTimer = setTimeout(() => {
-                lufss = -60
+                lufsm = -60
                 rms   = -60
             }, 500)
-        }
-
-        /*  setup chunking interval  */
-        this.calcInterval = setInterval(() => {
-            if (this.destroyed)
-                return
-
-            /*  process one single 50ms chunk if available  */
-            if (this.chunkBuffer.length >= samplesPerChunk) {
-                const chunkData = this.chunkBuffer.slice(0, samplesPerChunk)
-                this.chunkBuffer = this.chunkBuffer.slice(samplesPerChunk)
-                processChunk(chunkData)
-            }
         }, chunkDuration * 1000)
 
         /*  setup loudness emitting interval  */
         this.emitInterval = setInterval(() => {
-            if (this.destroyed)
+            if (this.closing)
                 return
-            this.log("debug", `LUFS-S: ${lufss.toFixed(1)} dB, RMS: ${rms.toFixed(1)} dB`)
-            this.sendResponse([ "meter", "LUFS-S", lufss ])
+            this.log("debug", `LUFS-M: ${lufsm.toFixed(1)} dB, RMS: ${rms.toFixed(1)} dB`)
+            this.sendResponse([ "meter", "LUFS-M", lufsm ])
             this.sendResponse([ "meter", "RMS", rms ])
             if (this.params.dashboard !== "")
-                this.sendDashboard("audio", this.params.dashboard, "final", lufss)
+                this.sendDashboard("audio", this.params.dashboard, "final", lufsm)
         }, this.params.interval)
 
         /*  provide Duplex stream and internally attach to meter  */
@@ -132,7 +152,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
             /*  transform audio chunk  */
             transform (chunk: SpeechFlowChunk, encoding, callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback(new Error("stream already destroyed"))
                     return
                 }
@@ -158,12 +178,12 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
                         callback()
                     }
                     catch (error) {
-                        callback(error instanceof Error ? error : new Error("meter processing failed"))
+                        callback(util.ensureError(error, "meter processing failed"))
                     }
                 }
             },
             final (callback) {
-                if (self.destroyed || self.params.mode === "sink") {
+                if (self.closing || self.params.mode === "sink") {
                     callback()
                     return
                 }
@@ -175,6 +195,9 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
+        /*  indicate closing immediately to stop any ongoing operations  */
+        this.closing = true
+
         /*  stop intervals  */
         if (this.emitInterval !== null) {
             clearInterval(this.emitInterval)
@@ -189,13 +212,10 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
             this.silenceTimer = null
         }
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
-
-        /*  indicate destruction  */
-        this.destroyed = true
     }
 }

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

@@ -9,6 +9,7 @@ import Stream from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as util                           from "./speechflow-util"
 
 /*  the type of muting  */
 type MuteMode =
@@ -23,7 +24,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
 
     /*  internal state  */
     private muteMode: MuteMode = "none"
-    private destroyed = false
+    private closing = false
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -39,7 +40,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
 
     /*  receive external request  */
     async receiveRequest (params: any[]) {
-        if (this.destroyed)
+        if (this.closing)
             throw new Error("mute: node already destroyed")
         try {
             if (params.length === 2 && params[0] === "mode") {
@@ -61,7 +62,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
 
     /*  change mute mode  */
     setMuteMode (mode: MuteMode) {
-        if (this.destroyed) {
+        if (this.closing) {
             this.log("warning", "attempted to set mute mode on destroyed node")
             return
         }
@@ -72,7 +73,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
     /*  open node  */
     async open () {
         /*  clear destruction flag  */
-        this.destroyed = false
+        this.closing = false
 
         /*  establish a transform stream  */
         const self = this
@@ -81,7 +82,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
             writableObjectMode: true,
             decodeStrings:      false,
             transform (chunk: SpeechFlowChunk, encoding, callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback(new Error("stream already destroyed"))
                     return
                 }
@@ -106,7 +107,7 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback()
                     return
                 }
@@ -118,12 +119,12 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
-        /*  indicate destruction  */
-        this.destroyed = true
+        /*  indicate closing  */
+        this.closing = true
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
     }

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

@@ -0,0 +1,221 @@
+/*
+**  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 path   from "node:path"
+import Stream from "node:stream"
+
+/*  external dependencies  */
+import { AudioWorkletNode } from "node-web-audio-api"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as util                           from "./speechflow-util"
+
+/*  parameter configuration  */
+type AudioPitchShifterConfig = {
+    rate?:      number
+    tempo?:     number
+    pitch?:     number
+    semitones?: number
+}
+
+/*  audio pitch shifter class using SoundTouch WebAudio worklet  */
+class AudioPitchShifter extends util.WebAudio {
+    /*  internal state  */
+    private pitchNode: AudioWorkletNode | null = null
+    private config: Required<AudioPitchShifterConfig>
+
+    /*  construct object  */
+    constructor (
+        sampleRate: number,
+        channels:   number,
+        config:     AudioPitchShifterConfig = {}
+    ) {
+        super(sampleRate, channels)
+        this.config = {
+            rate:      config.rate      ?? 1.0,
+            tempo:     config.tempo     ?? 1.0,
+            pitch:     config.pitch     ?? 1.0,
+            semitones: config.semitones ?? 0.0
+        }
+    }
+
+    /*  setup object  */
+    public async setup (): Promise<void> {
+        await super.setup()
+
+        /*  add SoundTouch worklet module  */
+        const packagePath = path.join(__dirname, "../node_modules/@soundtouchjs/audio-worklet")
+        const workletPath = path.join(packagePath, "dist/soundtouch-worklet.js")
+        await this.audioContext.audioWorklet.addModule(workletPath)
+
+        /*  create SoundTouch worklet node  */
+        this.pitchNode = new AudioWorkletNode(this.audioContext, "soundtouch-processor", {
+            numberOfInputs:  1,
+            numberOfOutputs: 1,
+            outputChannelCount: [ this.channels ]
+        })
+
+        /*  set initial parameter values  */
+        const params = this.pitchNode.parameters as Map<string, AudioParam>
+        params.get("rate")!.value           = this.config.rate
+        params.get("tempo")!.value          = this.config.tempo
+        params.get("pitch")!.value          = this.config.pitch
+        params.get("pitchSemitones")!.value = this.config.semitones
+
+        /*  connect nodes: source -> pitch -> capture  */
+        this.sourceNode!.connect(this.pitchNode)
+        this.pitchNode.connect(this.captureNode!)
+    }
+
+    /*  update an audio parameter value  */
+    private updateParameter (
+        paramName:   string,
+        value:       number,
+        configField: keyof Required<AudioPitchShifterConfig>
+    ): void {
+        const params = this.pitchNode?.parameters as Map<string, AudioParam>
+        params?.get(paramName)?.setValueAtTime(value, this.audioContext.currentTime)
+        this.config[configField] = value
+    }
+
+    /*  update rate value  */
+    public setRate (rate: number): void {
+        this.updateParameter("rate", rate, "rate")
+    }
+
+    /*  update tempo value  */
+    public setTempo (tempo: number): void {
+        this.updateParameter("tempo", tempo, "tempo")
+    }
+
+    /*  update pitch shift value  */
+    public setPitch (pitch: number): void {
+        this.updateParameter("pitch", pitch, "pitch")
+    }
+
+    /*  update pitch semitones setting  */
+    public setSemitones (semitones: number): void {
+        this.updateParameter("pitchSemitones", semitones, "semitones")
+    }
+
+    /*  destroy the pitch shifter  */
+    public async destroy (): Promise<void> {
+        /*  disconnect pitch node  */
+        if (this.pitchNode !== null) {
+            this.pitchNode.disconnect()
+            this.pitchNode = null
+        }
+
+        /*  destroy parent  */
+        await super.destroy()
+    }
+}
+
+/*  SpeechFlow node for pitch adjustment using SoundTouch WebAudio  */
+export default class SpeechFlowNodeA2APitch extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "a2a-pitch"
+
+    /*  internal state  */
+    private closing = false
+    private pitchShifter: AudioPitchShifter | 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({
+            rate:      { type: "number",  val: 1.0,  match: (n: number) => n >= 0.25 && n <= 4.0 },
+            tempo:     { type: "number",  val: 1.0,  match: (n: number) => n >= 0.25 && n <= 4.0 },
+            pitch:     { type: "number",  val: 1.0,  match: (n: number) => n >= 0.25 && n <= 4.0 },
+            semitones: { type: "number",  val: 0.0,  match: (n: number) => n >= -24  && n <= 24  }
+        })
+
+        /*  declare node input/output format  */
+        this.input  = "audio"
+        this.output = "audio"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  clear destruction flag  */
+        this.closing = false
+
+        /*  setup pitch shifter  */
+        this.pitchShifter = new AudioPitchShifter(
+            this.config.audioSampleRate,
+            this.config.audioChannels, {
+                rate:      this.params.rate,
+                tempo:     this.params.tempo,
+                pitch:     this.params.pitch,
+                semitones: this.params.semitones
+            }
+        )
+        await this.pitchShifter.setup()
+
+        /*  establish a transform stream  */
+        const self = this
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
+                if (self.closing) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
+                if (!Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else {
+                    /*  shift pitch of audio chunk  */
+                    const payload = util.convertBufToI16(chunk.payload, self.config.audioLittleEndian)
+                    self.pitchShifter?.process(payload).then((result) => {
+                        if (self.closing)
+                            throw new Error("stream already destroyed")
+
+                        /*  take over pitch-shifted data  */
+                        const payload = util.convertI16ToBuf(result, self.config.audioLittleEndian)
+                        chunk.payload = payload
+                        this.push(chunk)
+                        callback()
+                    }).catch((error: unknown) => {
+                        if (!self.closing)
+                            callback(util.ensureError(error, "pitch shifting failed"))
+                    })
+                }
+            },
+            final (callback) {
+                if (self.closing) {
+                    callback()
+                    return
+                }
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  indicate closing  */
+        this.closing = true
+
+        /*  destroy pitch shifter  */
+        if (this.pitchShifter !== null) {
+            await this.pitchShifter.destroy()
+            this.pitchShifter = null
+        }
+
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
+        }
+    }
+}

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

@@ -19,7 +19,7 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
     public static name = "a2a-rnnoise"
 
     /*  internal state  */
-    private destroyed = false
+    private closing = false
     private sampleSize = 480 /* = 10ms at 48KHz, as required by RNNoise! */
     private worker: Worker | null = null
 
@@ -38,12 +38,13 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
     /*  open node  */
     async open () {
         /*  clear destruction flag  */
-        this.destroyed = false
+        this.closing = false
 
         /*  initialize worker  */
         this.worker = new Worker(resolve(__dirname, "speechflow-node-a2a-rnnoise-wt.js"))
         this.worker.on("error", (err) => {
             this.log("error", `RNNoise worker thread error: ${err}`)
+            this.stream?.emit("error", err)
         })
         this.worker.on("exit", (code) => {
             if (code !== 0)
@@ -88,7 +89,7 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
         /*  send message to worker  */
         let seq = 0
         const workerProcessSegment = async (segment: Int16Array<ArrayBuffer>) => {
-            if (this.destroyed)
+            if (this.closing)
                 return segment
             const id = `${seq++}`
             return new Promise<Int16Array<ArrayBuffer>>((resolve) => {
@@ -104,7 +105,7 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
             writableObjectMode: true,
             decodeStrings:      false,
             transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback(new Error("stream already destroyed"))
                     return
                 }
@@ -127,14 +128,15 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
                         /*  forward updated chunk  */
                         this.push(chunk)
                         callback()
-                    }).catch((err: Error) => {
-                        self.log("warning", `processing of chunk failed: ${err}`)
-                        callback(err)
+                    }).catch((err: unknown) => {
+                        const error = util.ensureError(err)
+                        self.log("warning", `processing of chunk failed: ${error.message}`)
+                        callback(error)
                     })
                 }
             },
             final (callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback()
                     return
                 }
@@ -146,8 +148,8 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
-        /*  indicate destruction  */
-        this.destroyed = true
+        /*  indicate closing  */
+        this.closing = true
 
         /*  shutdown worker  */
         if (this.worker !== null) {
@@ -155,9 +157,9 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
             this.worker = null
         }
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
     }

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

@@ -22,7 +22,7 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
     public static name = "a2a-speex"
 
     /*  internal state  */
-    private destroyed = false
+    private closing = false
     private sampleSize = 480 /* = 10ms at 48KHz */
     private speexProcessor: SpeexPreprocessor | null = null
 
@@ -43,7 +43,7 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
     /*  open node  */
     async open () {
         /*  clear destruction flag  */
-        this.destroyed = false
+        this.closing = false
 
         /*  validate sample rate compatibility  */
         if (this.config.audioSampleRate !== 48000)
@@ -71,7 +71,7 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
             writableObjectMode: true,
             decodeStrings:      false,
             transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback(new Error("stream already destroyed"))
                     return
                 }
@@ -83,12 +83,12 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
 
                     /*  process Int16Array in necessary fixed-size segments  */
                     util.processInt16ArrayInSegments(payload, self.sampleSize, (segment) => {
-                        if (self.destroyed)
+                        if (self.closing)
                             throw new Error("stream already destroyed")
                         self.speexProcessor?.processInt16(segment)
                         return Promise.resolve(segment)
                     }).then((payload: Int16Array<ArrayBuffer>) => {
-                        if (self.destroyed)
+                        if (self.closing)
                             throw new Error("stream already destroyed")
 
                         /*  convert Int16Array back into Buffer  */
@@ -100,14 +100,15 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
                         /*  forward updated chunk  */
                         this.push(chunk)
                         callback()
-                    }).catch((err: Error) => {
-                        self.log("warning", `processing of chunk failed: ${err}`)
-                        callback(err)
+                    }).catch((err: unknown) => {
+                        const error = util.ensureError(err)
+                        self.log("warning", `processing of chunk failed: ${error.message}`)
+                        callback(error)
                     })
                 }
             },
             final (callback) {
-                if (self.destroyed) {
+                if (self.closing) {
                     callback()
                     return
                 }
@@ -119,8 +120,8 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
-        /*  indicate destruction  */
-        this.destroyed = true
+        /*  indicate closing  */
+        this.closing = true
 
         /*  destroy processor  */
         if (this.speexProcessor !== null) {
@@ -128,9 +129,9 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
             this.speexProcessor = null
         }
 
-        /*  close stream  */
+        /*  shutdown stream  */
         if (this.stream !== null) {
-            this.stream.destroy()
+            await util.destroyStream(this.stream)
             this.stream = null
         }
     }