speechflow 0.9.0 → 0.9.1

package/README.md

@@ -141,6 +141,20 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **device**  | 0         | *none*   | `/^(.+?):(.+)$/`   |
   | **mode**    | 1         | "rw"     | `/^(?:r\|w\|rw)$/` |
 
+- Node: **ffmpeg**<br/>
+  Purpose: **FFmpeg audio format conversion**<br/>
+  Example: `ffmpeg(src: "pcm", dst: "mp3")`
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | audio       |
+  | output  | audio       |
+
+  | Parameter   | Position  | Default  | Requirement        |
+  | ----------- | --------- | -------- | ------------------ |
+  | **src**     | 0         | "pcm"    | `/^(?:pcm\|wav\|mp3\|opus)$/` |
+  | **dst**     | 1         | "wav"    | `/^(?:pcm\|wav\|mp3\|opus)$/` |
+
 - Node: **deepgram**<br/>
   Purpose: **Deepgram Speech-to-Text conversion**<br/>
   Example: `deepgram(language: "de")`<br/>
@@ -174,6 +188,22 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **src**      | 0         | "de"     | `/^(?:de\|en-US)$/` |
   | **dst**      | 1         | "en-US"  | `/^(?:de\|en-US)$/` |
 
+- Node: **gemma**<br/>
+  Purpose: **Google Gemma Text-to-Text translation**<br/>
+  Example: `gemma(src: "de", dst: "en")`<br/>
+  Notice; this node requires the Ollama API!
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | text        |
+  | output  | text        |
+
+  | Parameter    | Position  | Default  | Requirement        |
+  | ------------ | --------- | -------- | ------------------ |
+  | **url**      | *none*    | "http://127.0.0.1:11434" | `/^https?:\/\/.+?:\d+$/` |
+  | **src**      | 0         | "de"     | `/^(?:de\|en)$/` |
+  | **dst**      | 1         | "en"     | `/^(?:de\|en)$/` |
+
 - Node: **elevenlabs**<br/>
   Purpose: **ElevenLabs Text-to-Speech conversion**<br/>
   Example: `elevenlabs(language: "en")`<br/>

package/dst/speechflow-node-deepgram.d.ts

@@ -0,0 +1,10 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeDeepgram extends SpeechFlowNode {
+    static name: string;
+    private dg;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-deepgram.js

@@ -41,30 +41,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_events_1 = require("node:events");
+/*  external dependencies  */
 const node_stream_1 = __importDefault(require("node:stream"));
 const Deepgram = __importStar(require("@deepgram/sdk"));
+/*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
-class SpeechFlowNodeDevice extends speechflow_node_1.default {
+/*  SpeechFlow node for Deepgram speech-to-text conversion  */
+class SpeechFlowNodeDeepgram extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "deepgram";
+    /*  internal state  */
     dg = null;
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
+        /*  declare node configuration parameters  */
         this.configure({
             key: { type: "string", val: process.env.SPEECHFLOW_KEY_DEEPGRAM },
-            model: { type: "string", val: "nova-2", pos: 0 }, /* FIXME: nova-3 multiligual */
+            model: { type: "string", val: "nova-3", pos: 0 },
             version: { type: "string", val: "latest", pos: 1 },
-            language: { type: "string", val: "de", pos: 2 }
+            language: { type: "string", val: "multi", pos: 2 }
         });
-    }
-    async open() {
+        /*  declare node input/output format  */
         this.input = "audio";
         this.output = "text";
-        this.stream = null;
+    }
+    /*  open node  */
+    async open() {
         /*  sanity check situation  */
         if (this.config.audioBitDepth !== 16 || !this.config.audioLittleEndian)
             throw new Error("Deepgram node currently supports PCM-S16LE audio only");
-        /*  connect to Deepgram API  */
+        /*  create queue for results  */
         const queue = new node_events_1.EventEmitter();
+        /*  connect to Deepgram API  */
         const deepgram = Deepgram.createClient(this.params.key);
         this.dg = deepgram.listen.live({
             model: this.params.model,
@@ -74,7 +85,7 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             sample_rate: this.config.audioSampleRate,
             encoding: "linear16",
             multichannel: false,
-            // endpointing:      false,  /* FIXME: ? */
+            endpointing: 10,
             interim_results: false,
             smart_format: true,
             punctuate: true,
@@ -83,26 +94,31 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             numerals: true,
             paragraphs: true,
             profanity_filter: true,
-            utterances: false,
-        });
-        await new Promise((resolve) => {
-            this.dg.on(Deepgram.LiveTranscriptionEvents.Open, () => {
-                this.log("info", "Deepgram: connection open");
-                resolve(true);
-            });
-        });
-        /*  hooks onto Deepgram API events  */
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Close, () => {
-            this.log("info", "Deepgram: connection close");
+            utterances: false
         });
+        /*  hook onto Deepgram API events  */
         this.dg.on(Deepgram.LiveTranscriptionEvents.Transcript, async (data) => {
             const text = data.channel?.alternatives[0].transcript ?? "";
             if (text === "")
                 return;
             queue.emit("text", text);
         });
+        this.dg.on(Deepgram.LiveTranscriptionEvents.Metadata, (data) => {
+            this.log("info", "Deepgram: metadata received");
+        });
+        this.dg.on(Deepgram.LiveTranscriptionEvents.Close, () => {
+            this.log("info", "Deepgram: connection close");
+        });
         this.dg.on(Deepgram.LiveTranscriptionEvents.Error, (error) => {
-            this.log("error", `Deepgram: ${error}`);
+            this.log("error", `Deepgram: ${error.message}`);
+            this.emit("error");
+        });
+        /*  wait for Deepgram API to be available  */
+        await new Promise((resolve) => {
+            this.dg.once(Deepgram.LiveTranscriptionEvents.Open, () => {
+                this.log("info", "Deepgram: connection open");
+                resolve(true);
+            });
         });
         /*  provide Duplex stream and internally attach to Deepgram API  */
         const dg = this.dg;
@@ -117,19 +133,24 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             },
             read(size) {
                 queue.once("text", (text) => {
-                    if (text !== "")
-                        this.push(text);
+                    this.push(text);
                 });
+            },
+            final(callback) {
+                dg.requestClose();
             }
         });
     }
+    /*  close node  */
     async close() {
+        /*  close stream  */
         if (this.stream !== null) {
             this.stream.destroy();
             this.stream = null;
         }
+        /*  shutdown Deepgram API  */
         if (this.dg !== null)
             this.dg.requestClose();
     }
 }
-exports.default = SpeechFlowNodeDevice;
+exports.default = SpeechFlowNodeDeepgram;

package/dst/speechflow-node-deepl.d.ts

@@ -0,0 +1,10 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeDeepL extends SpeechFlowNode {
+    static name: string;
+    private deepl;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-deepl.js

@@ -41,34 +41,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_stream_1 = __importDefault(require("node:stream"));
 const node_events_1 = require("node:events");
-const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  external dependencies  */
 const DeepL = __importStar(require("deepl-node"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for DeepL text-to-text translations  */
 class SpeechFlowNodeDeepL extends speechflow_node_1.default {
-    translator = null;
+    /*  declare official node name  */
+    static name = "deepl";
+    /*  internal state  */
+    deepl = null;
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
-        this.input = "text";
-        this.output = "text";
-        this.stream = null;
+        /*  declare node configuration parameters  */
         this.configure({
             key: { type: "string", val: process.env.SPEECHFLOW_KEY_DEEPL },
             src: { type: "string", pos: 0, val: "de", match: /^(?:de|en-US)$/ },
-            dst: { type: "string", pos: 1, val: "en-US", match: /^(?:de|en-US)$/ }
+            dst: { type: "string", pos: 1, val: "en-US", match: /^(?:de|en-US)$/ },
+            optimize: { type: "string", pos: 2, val: "latency", match: /^(?:latency|quality)$/ }
         });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
     }
+    /*  open node  */
     async open() {
         /*  instantiate DeepL API SDK  */
-        this.translator = new DeepL.Translator(this.params.key);
+        this.deepl = new DeepL.Translator(this.params.key);
         /*  provide text-to-text translation  */
         const translate = async (text) => {
-            const result = await this.translator.translateText(text, this.params.src, this.params.dst, {
-                splitSentences: "off"
+            const result = await this.deepl.translateText(text, this.params.src, this.params.dst, {
+                splitSentences: "off",
+                modelType: this.params.optimize === "latency" ?
+                    "latency_optimized" : "prefer_quality_optimized",
+                preserveFormatting: true,
+                formality: "prefer_more"
             });
             return (result?.text ?? text);
         };
-        /*  establish a duplex stream and connect it to the translation  */
+        /*  establish a duplex stream and connect it to DeepL translation  */
         const queue = new node_events_1.EventEmitter();
         this.stream = new node_stream_1.default.Duplex({
             write(chunk, encoding, callback) {
@@ -93,13 +108,16 @@ class SpeechFlowNodeDeepL extends speechflow_node_1.default {
             }
         });
     }
+    /*  open node  */
     async close() {
+        /*  close stream  */
         if (this.stream !== null) {
             this.stream.destroy();
             this.stream = null;
         }
-        if (this.translator !== null)
-            this.translator = null;
+        /*  shutdown DeepL API  */
+        if (this.deepl !== null)
+            this.deepl = null;
     }
 }
 exports.default = SpeechFlowNodeDeepL;

package/dst/speechflow-node-device.d.ts

@@ -0,0 +1,11 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeDevice extends SpeechFlowNode {
+    static name: string;
+    private io;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    private audioDeviceFromURL;
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-device.js

@@ -8,34 +8,85 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  external dependencies  */
 const naudiodon_1 = __importDefault(require("@gpeng/naudiodon"));
+/*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
-const speechflow_util_1 = __importDefault(require("./speechflow-util"));
+/*  SpeechFlow node for device access  */
 class SpeechFlowNodeDevice extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "device";
+    /*  internal state  */
     io = null;
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
+        /*  declare node configuration parameters  */
         this.configure({
             device: { type: "string", pos: 0, match: /^(.+?):(.+)$/ },
             mode: { type: "string", pos: 1, val: "rw", match: /^(?:r|w|rw)$/ }
         });
+        /*  declare node input/output format  */
+        if (this.params.mode === "rw") {
+            this.input = "audio";
+            this.output = "audio";
+        }
+        else if (this.params.mode === "r") {
+            this.input = "none";
+            this.output = "audio";
+        }
+        else if (this.params.mode === "w") {
+            this.input = "audio";
+            this.output = "none";
+        }
     }
+    /*  INTERNAL: utility function for finding audio device by pseudo-URL notation  */
+    audioDeviceFromURL(mode, url) {
+        /*  parse URL  */
+        const m = url.match(/^(.+?):(.+)$/);
+        if (m === null)
+            throw new Error(`invalid audio device URL "${url}"`);
+        const [, type, name] = m;
+        /*  determine audio API  */
+        const apis = naudiodon_1.default.getHostAPIs();
+        const api = apis.HostAPIs.find((api) => api.type.toLowerCase() === type.toLowerCase());
+        if (!api)
+            throw new Error(`invalid audio API type "${type}"`);
+        /*  determine device of audio API  */
+        const devices = naudiodon_1.default.getDevices();
+        const device = devices.find((device) => {
+            return (((mode === "r" && device.maxInputChannels > 0)
+                || (mode === "w" && device.maxOutputChannels > 0)
+                || (mode === "rw" && device.maxInputChannels > 0 && device.maxOutputChannels > 0)
+                || (mode === "any" && (device.maxInputChannels > 0 || device.maxOutputChannels > 0)))
+                && device.name.match(name)
+                && device.hostAPIName === api.name);
+        });
+        if (!device)
+            throw new Error(`invalid audio device "${name}" (of audio API type "${type}")`);
+        return device;
+    }
+    /*  open node  */
     async open() {
         /*  determine device  */
-        const device = speechflow_util_1.default.audioDeviceFromURL(this.params.mode, this.params.device);
+        const device = this.audioDeviceFromURL(this.params.mode, this.params.device);
         /*  sanity check sample rate compatibility
             (we still do not resample in input/output for simplification reasons)  */
         if (device.defaultSampleRate !== this.config.audioSampleRate)
-            throw new Error(`device audio sample rate ${device.defaultSampleRate} is ` +
+            throw new Error(`audio device sample rate ${device.defaultSampleRate} is ` +
                 `incompatible with required sample rate ${this.config.audioSampleRate}`);
         /*  establish device connection
             Notice: "naudion" 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}  */
-        if (device.maxInputChannels > 0 && device.maxOutputChannels > 0) {
+        /*  FIXME: the underlying PortAudio outputs verbose/debugging messages  */
+        if (this.params.mode === "rw") {
+            /*  input/output device  */
+            if (device.maxInputChannels === 0)
+                throw new Error(`device "${device.id}" does not have any input channels (required by read/write mode)`);
+            if (device.maxOutputChannels === 0)
+                throw new Error(`device "${device.id}" does not have any output channels (required by read/write mode)`);
             this.log("info", `resolved "${this.params.device}" to duplex device "${device.id}"`);
-            this.input = "audio";
-            this.output = "audio";
             this.io = naudiodon_1.default.AudioIO({
                 inOptions: {
                     deviceId: device.id,
@@ -52,10 +103,11 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             });
             this.stream = this.io;
         }
-        else if (device.maxInputChannels > 0 && device.maxOutputChannels === 0) {
+        else if (this.params.mode === "r") {
+            /*  input device  */
+            if (device.maxInputChannels === 0)
+                throw new Error(`device "${device.id}" does not have any input channels (required by read mode)`);
             this.log("info", `resolved "${this.params.device}" to input device "${device.id}"`);
-            this.input = "none";
-            this.output = "audio";
             this.io = naudiodon_1.default.AudioIO({
                 inOptions: {
                     deviceId: device.id,
@@ -66,10 +118,11 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             });
             this.stream = this.io;
         }
-        else if (device.maxInputChannels === 0 && device.maxOutputChannels > 0) {
+        else if (this.params.mode === "w") {
+            /*  output device  */
+            if (device.maxOutputChannels === 0)
+                throw new Error(`device "${device.id}" does not have any output channels (required by write mode)`);
             this.log("info", `resolved "${this.params.device}" to output device "${device.id}"`);
-            this.input = "audio";
-            this.output = "none";
             this.io = naudiodon_1.default.AudioIO({
                 outOptions: {
                     deviceId: device.id,
@@ -82,14 +135,20 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
         }
         else
             throw new Error(`device "${device.id}" does not have any input or output channels`);
-        /*  pass-through errors  */
+        /*  pass-through PortAudio errors  */
         this.io.on("error", (err) => {
             this.emit("error", err);
         });
+        /*  start PortAudio  */
+        this.io.start();
     }
+    /*  close node  */
     async close() {
-        if (this.io !== null)
+        /*  shutdown PortAudio  */
+        if (this.io !== null) {
             this.io.quit();
+            this.io = null;
+        }
     }
 }
 exports.default = SpeechFlowNodeDevice;

package/dst/speechflow-node-elevenlabs.d.ts

@@ -0,0 +1,10 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeElevenlabs extends SpeechFlowNode {
+    static name: string;
+    private elevenlabs;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-elevenlabs.js

@@ -41,10 +41,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_stream_1 = __importDefault(require("node:stream"));
 const node_events_1 = require("node:events");
+/*  external dependencies  */
 const ElevenLabs = __importStar(require("elevenlabs"));
 const get_stream_1 = require("get-stream");
+/*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
 /*
 const elevenlabsVoices = {
@@ -61,18 +64,25 @@ const elevenlabsVoices = {
 }
 */
 class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "elevenlabs";
+    /*  internal state  */
     elevenlabs = null;
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
+        /*  declare node configuration parameters  */
         this.configure({
             key: { type: "string", val: process.env.SPEECHFLOW_KEY_ELEVENLABS },
             voice: { type: "string", val: "Brian", pos: 0 },
             language: { type: "string", val: "de", pos: 1 }
         });
-    }
-    async open() {
+        /*  declare node input/output format  */
         this.input = "text";
         this.output = "audio";
+    }
+    /*  open node  */
+    async open() {
         this.elevenlabs = new ElevenLabs.ElevenLabsClient({
             apiKey: this.params.key
         });
@@ -121,7 +131,9 @@ class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
             }
         });
     }
+    /*  close node  */
     async close() {
+        /*  destroy stream  */
         if (this.stream !== null) {
             this.stream.destroy();
             this.stream = null;

package/dst/speechflow-node-ffmpeg.d.ts

@@ -0,0 +1,11 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeFFmpeg extends SpeechFlowNode {
+    static name: string;
+    private ffmpegBinary;
+    private ffmpeg;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-ffmpeg.js

@@ -0,0 +1,114 @@
+"use strict";
+/*
+**  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>
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
+const node_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
+const ffmpeg_1 = __importDefault(require("@rse/ffmpeg"));
+const ffmpeg_stream_1 = require("ffmpeg-stream");
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for FFmpeg  */
+class SpeechFlowNodeFFmpeg extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "ffmpeg";
+    /*  internal state  */
+    ffmpegBinary = ffmpeg_1.default.supported ? ffmpeg_1.default.binary : "ffmpeg";
+    ffmpeg = null;
+    /*  construct node  */
+    constructor(id, opts, args) {
+        super(id, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            src: { type: "string", pos: 0, val: "pcm", match: /^(?:pcm|wav|mp3|opus)$/ },
+            dst: { type: "string", pos: 1, val: "wav", match: /^(?:pcm|wav|mp3|opus)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "audio";
+        this.output = "audio";
+    }
+    /*  open node  */
+    async open() {
+        /*  sanity check situation  */
+        if (this.params.src === this.params.dst)
+            throw new Error("source and destination formats should not be the same");
+        /*  instantiate FFmpeg sub-process  */
+        this.ffmpeg = new ffmpeg_stream_1.Converter(this.ffmpegBinary);
+        const streamInput = this.ffmpeg.createInputStream({
+            /*  FFmpeg input options  */
+            "fflags": "nobuffer",
+            "flags": "low_delay",
+            "probesize": 32,
+            "analyzeduration": 0,
+            ...(this.params.src === "pcm" ? {
+                "f": "s16le",
+                "ar": this.config.audioSampleRate,
+                "ac": this.config.audioChannels
+            } : {}),
+            ...(this.params.src === "wav" ? {
+                "f": "wav"
+            } : {}),
+            ...(this.params.src === "mp3" ? {
+                "f": "mp3"
+            } : {}),
+            ...(this.params.src === "opus" ? {
+                "f": "opus"
+            } : {})
+        });
+        const streamOutput = this.ffmpeg.createOutputStream({
+            /*  FFmpeg output options  */
+            "flush_packets": 1,
+            ...(this.params.dst === "pcm" ? {
+                "c:a": "pcm_s16le",
+                "ar": this.config.audioSampleRate,
+                "ac": this.config.audioChannels,
+                "f": "s16le",
+            } : {}),
+            ...(this.params.dst === "wav" ? {
+                "f": "wav"
+            } : {}),
+            ...(this.params.dst === "mp3" ? {
+                "c:a": "libmp3lame",
+                "b:a": "192k",
+                "f": "mp3"
+            } : {}),
+            ...(this.params.dst === "opus" ? {
+                "acodec": "libopus",
+                "f": "opus"
+            } : {})
+        });
+        this.ffmpeg.run();
+        /*  establish a duplex stream and connect it to FFmpeg  */
+        this.stream = node_stream_1.default.Duplex.from({
+            readable: streamOutput,
+            writable: streamInput
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close duplex stream  */
+        if (this.stream !== null) {
+            await new Promise((resolve) => {
+                if (this.stream instanceof node_stream_1.default.Duplex)
+                    this.stream.end(() => { resolve(); });
+                else
+                    resolve();
+            });
+            this.stream.destroy();
+            this.stream = null;
+        }
+        /*  shutdown FFmpeg  */
+        if (this.ffmpeg !== null) {
+            this.ffmpeg.kill();
+            this.ffmpeg = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeFFmpeg;

package/dst/speechflow-node-file.d.ts

@@ -0,0 +1,9 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeFile extends SpeechFlowNode {
+    static name: string;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}