speechflow 0.9.5 → 0.9.8

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+
+ChangeLog
+=========
+
+0.9.8 (2025-07-12)
+------------------
+
+- CLEANUP: provide start scripts and move config to sub-directory
+
+0.9.7 (2025-07-12)
+------------------
+
+- IMPROVEMENT: replace "nps" with "stx" for NPM scripting
+
+0.9.6 (2025-07-12)
+------------------
+
+- IMPROVEMENT: major refactoring to object-mode streaming for supporting timestamps
+
+0.9.5 (2025-04-27)
+------------------
+
+(first rough cut of program)
+

package/README.md

@@ -18,13 +18,24 @@ About
 directed data flow graph of audio and text processing nodes. This way,
 it allows to perform various speech processing tasks in a flexible way.
 
-**SpeechFlow** comes with built-in graph nodes for local file I/O, local audio
-device I/O, local/remote WebSocket network I/O, cloud-based [Deepgram](https://deepgram.com)
-speech-to-text conversion, cloud-based [DeepL](https://deepl.com) text-to-text
-translation, local [Gemma/Ollama](https://ollama.com/library/gemma3)
-text-to-text translation, cloud-based [ElevenLabs](https://elevenlabs.io/)
-text-to-speech conversion, and local [FFmpeg](https://ffmpeg.org/)
-speech-to-speech encoding. Additional SpeechFlow graph nodes can be provided externally
+**SpeechFlow** comes with built-in graph nodes for
+local file I/O,
+local audio device I/O,
+remote WebSocket network I/O,
+remote MQTT network I/O,
+cloud-based [Deepgram](https://deepgram.com) speech-to-text conversion,
+cloud-based [ElevenLabs](https://elevenlabs.io/) text-to-speech conversion,
+cloud-based [DeepL](https://deepl.com) text-to-text translation,
+local [Gemma/Ollama](https://ollama.com/library/gemma3) text-to-text translation,
+local [Gemma/Ollama](https://ollama.com/library/gemma3) text-to-text spelling correction,
+local [OPUS/ONNX](https://github.com/Helsinki-NLP/Opus-MT) text-to-text translation,
+local [FFmpeg](https://ffmpeg.org/) speech-to-speech encoding,
+local WAV speech-to-speech encoding,
+local text-to-text formatting,
+local text-to-text subtitle generation, and
+local text or audio tracing.
+
+Additional **SpeechFlow** graph nodes can be provided externally
 by NPM packages named `speechflow-node-xxx` which expose a class
 derived from the exported `SpeechFlowNode` class of the `speechflow` package.
 
@@ -47,60 +58,93 @@ $ speechflow
   [-V|--version]
   [-v|--verbose <level>]
   [-e|--expression <expression>]
-  [-f|--expression-file <expression-file>]
-  [-c|--config <key>@<yaml-config-file>]
+  [-f|--file <file>]
+  [-c|--config <id>@<yaml-config-file>]
   [<argument> [...]]
 ```
 
 Processing Graph Examples
 -------------------------
 
-- Capture audio from microphone to file:
+The following are examples of **SpeechFlow** processing graphs.
+They can also be found in the sample [speechflow.yaml](./etc/speechflow.yaml) file.
+
+- **Capturing**: Capture audio from microphone device into WAV audio file:
 
   ```
   device(device: "wasapi:VoiceMeeter Out B1", mode: "r") |
-  file(path: "capture.pcm", mode: "w", type: "audio")
+      wav(mode: "encode") |
+          file(path: "capture.wav", mode: "w", type: "audio")
   ```
 
-- Generate audio file with narration of text file:
+- **Pass-Through**: Pass-through audio from microphone device to speaker
+  device and in parallel record it to WAV audio file:
+
+  ```
+  device(device: "wasapi:VoiceMeeter Out B1", mode: "r") | {
+      wav(mode: "encode") |
+          file(path: "capture.wav", mode: "w", type: "audio"),
+      device(device: "wasapi:VoiceMeeter VAIO3 Input", mode: "w")
+  }
+  ```
+
+- **Narration**: Generate text file with German narration of MP3 audio file:
 
   ```
   file(path: argv.0, mode: "r", type: "audio") |
-  deepgram(language: "en") |
-  file(path: argv.1, mode: "w", type: "text")
+      ffmpeg(src: "mp3", dst: "pcm") |
+          deepgram(language: "de", key: env.SPEECHFLOW_KEY_DEEPGRAM) |
+              format(width: 80) |
+                  file(path: argv.1, mode: "w", type: "text")
   ```
 
-- Translate stdin to stdout:
+- **Subtitling**: Generate text file with German subtitles of MP3 audio file:
 
   ```
-  file(path: "-", mode: "r", type: "text") |
-  deepl(src: "de", dst: "en-US") |
-  file(path: "-", mode: "w", type: "text")
+  file(path: argv.0, mode: "r", type: "audio") |
+      ffmpeg(src: "mp3", dst: "pcm") |
+          deepgram(language: "de", key: env.SPEECHFLOW_KEY_DEEPGRAM) |
+              subtitle(format: "vtt") |
+                  file(path: argv.1, mode: "w", type: "text")
   ```
 
-- Pass-through audio from microphone to speaker and in parallel record it to file:
+- **Ad-Hoc Translation**: Ad-Hoc text translation from German to English
+  via stdin/stdout:
 
   ```
-  device(device: "wasapi:VoiceMeeter Out B1", mode: "r") | {
-      file(path: "capture.pcm", mode: "w", type: "audio"),
-      device(device: "wasapi:VoiceMeeter VAIO3 Input", mode: "w")
-  }
+  file(path: "-", mode: "r", type: "text") |
+      deepl(src: "de", dst: "en") |
+          file(path: "-", mode: "w", type: "text")
   ```
 
-- Real-time translation from german to english, including capturing of all inputs and outputs:
+- **Studio Translation**: Real-time studio translation from German to English,
+  including the capturing of all involved inputs and outputs:
 
   ```
-  device(device: "wasapi:VoiceMeeter Out B1", mode: "r") | {
-      file(path: "translation-audio-de.pcm", mode: "w", type: "audio"),
-      deepgram(language: "de") |
-      file(path: "translation-text-de.txt", mode: "w", type: "text")
-  } | {
-      deepl(src: "de", dst: "en-US") |
-      file(path: "translation-text-en.txt", mode: "w", type: "text")
-  } | {
-      elevenlabs(language: "en") | {
-          file(path: "translation-audio-en.pcm", mode: "w", type: "audio"),
-          device(device: "wasapi:VoiceMeeter VAIO3 Input", mode: "w")
+  device(device: "coreaudio:Elgato Wave:3", mode: "r") | {
+      wav(mode: "encode") |
+          file(path: "program-de.wav", mode: "w", type: "audio"),
+      deepgram(key: env.SPEECHFLOW_KEY_DEEPGRAM, language: "de") | {
+          format(width: 80) |
+              file(path: "program-de.txt", mode: "w", type: "text"),
+          deepl(key: env.SPEECHFLOW_KEY_DEEPL, src: "de", dst: "en") | {
+              format(width: 80) |
+                  file(path: "program-en.txt", mode: "w", type: "text"),
+              subtitle(format: "vtt") | {
+                  file(path: "program-en.vtt", mode: "w", type: "text"),
+                  mqtt(url: "mqtt://10.1.0.10:1883",
+                      username: env.SPEECHFLOW_MQTT_USER,
+                      password: env.SPEECHFLOW_MQTT_PASS,
+                      topicWrite: "stream/studio/sender")
+              },
+              subtitle(format: "srt") |
+                  file(path: "program-en.srt", mode: "w", type: "text"),
+              elevenlabs(voice: "Mark", speed: 1.05, language: "en") | {
+                  wav(mode: "encode") |
+                      file(path: "program-en.wav", mode: "w", type: "audio"),
+                  device(device: "coreaudio:USBAudio2.0", mode: "w")
+              }
+          }
       }
   }
   ```
@@ -108,7 +152,30 @@ Processing Graph Examples
 Processing Node Types
 ---------------------
 
-Currently **SpeechFlow** provides the following processing nodes:
+First a short overview of the available processing nodes:
+
+- Input/Output nodes:
+  **file**,
+  **device**,
+  **websocket**,
+  **mqtt**.
+- Audio-to-Audio nodes:
+  **ffmpeg**,
+  **wav**.
+- Audio-to-Text nodes:
+  **deepgram**.
+- Text-to-Text nodes:
+  **deepl**,
+  **gemma**,
+  **opus**,
+  **subtitle**,
+  **format**.
+- Text-to-Audio nodes:
+  **elevenlabs**.
+- Any-to-Any nodes:
+  **trace**.
+
+### Input/Output Nodes:
 
 - Node:    **file**<br/>
   Purpose: **File and StdIO source/sink**<br/>
@@ -125,9 +192,24 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **mode**   | 1         | "r"      | `/^(?:r\|w\|rw)$/`    |
   | **type**   | 2         | "audio"  | `/^(?:audio\|text)$/` |
 
+- Node: **device**<br/>
+  Purpose: **Microphone/speaker device source/sink**<br/>
+  Example: `device(device: "wasapi:VoiceMeeter Out B1", mode: "r")`
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | audio       |
+  | output  | audio       |
+
+  | Parameter   | Position  | Default  | Requirement        |
+  | ----------- | --------- | -------- | ------------------ |
+  | **device**  | 0         | *none*   | `/^(.+?):(.+)$/`   |
+  | **mode**    | 1         | "rw"     | `/^(?:r\|w\|rw)$/` |
+
 - Node: **websocket**<br/>
   Purpose: **WebSocket source/sink**<br/>
-  Example: `websocket(connect: "ws://127.0.0.1:12345". type: "text")`
+  Example: `websocket(connect: "ws://127.0.0.1:12345", type: "text")`
+  Notice: this node requires a peer WebSocket service!
 
   | Port    | Payload     |
   | ------- | ----------- |
@@ -140,19 +222,24 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **connect** | *none*    | *none*   | `/^(?:\|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/` |
   | **type**    | *none*    | "audio"  | `/^(?:audio\|text)$/` |
 
-- Node: **device**<br/>
-  Purpose: **Microphone/speaker device source/sink**<br/>
-  Example: `device(device: "wasapi:VoiceMeeter Out B1", mode: "r")`
+- Node: **mqtt**<br/>
+  Purpose: **MQTT sink**<br/>
+  Example: `mqtt(url: "mqtt://127.0.0.1:1883", username: "foo", password: "bar", topic: "quux")`
+  Notice: this node requires a peer MQTT broker!
 
   | Port    | Payload     |
   | ------- | ----------- |
-  | input   | audio       |
-  | output  | audio       |
+  | input   | text        |
+  | output  | none        |
 
-  | Parameter   | Position  | Default  | Requirement        |
-  | ----------- | --------- | -------- | ------------------ |
-  | **device**  | 0         | *none*   | `/^(.+?):(.+)$/`   |
-  | **mode**    | 1         | "rw"     | `/^(?:r\|w\|rw)$/` |
+  | Parameter    | Position  | Default  | Requirement           |
+  | ------------ | --------- | -------- | --------------------- |
+  | **url**      | 0         | *none*   | `/^(?:\|(?:ws|mqtt):\/\/(.+?):(\d+))$/` |
+  | **username** | 1         | *none*   | `/^.+$/` |
+  | **password** | 2         | *none*   | `/^.+$/` |
+  | **topic**    | 3         | *none*   | `/^.+$/` |
+
+### Audio-to-Audio Nodes:
 
 - Node: **ffmpeg**<br/>
   Purpose: **FFmpeg audio format conversion**<br/>
@@ -168,6 +255,21 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **src**     | 0         | "pcm"    | `/^(?:pcm\|wav\|mp3\|opus)$/` |
   | **dst**     | 1         | "wav"    | `/^(?:pcm\|wav\|mp3\|opus)$/` |
 
+- Node: **wav**<br/>
+  Purpose: **WAV audio format conversion**<br/>
+  Example: `wav(mode: "encode")`
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | audio       |
+  | output  | audio       |
+
+  | Parameter   | Position  | Default  | Requirement              |
+  | ----------- | --------- | -------- | ------------------------ |
+  | **mode**    | 0         | "encode" | `/^(?:encode\|decode)$/` |
+
+### Audio-to-Text Nodes:
+
 - Node: **deepgram**<br/>
   Purpose: **Deepgram Speech-to-Text conversion**<br/>
   Example: `deepgram(language: "de")`<br/>
@@ -181,13 +283,15 @@ Currently **SpeechFlow** provides the following processing nodes:
   | Parameter    | Position  | Default  | Requirement        |
   | ------------ | --------- | -------- | ------------------ |
   | **key**      | *none*    | env.SPEECHFLOW\_KEY\_DEEPGRAM | *none* |
-  | **model**    | 0         | "nova-2" | *none* |
+  | **model**    | 0         | "nova-3" | *none* |
   | **version**  | 1         | "latest" | *none* |
-  | **language** | 2         | "de"     | *none* |
+  | **language** | 2         | "multi"  | *none* |
+
+### Text-to-Text Nodes:
 
 - Node: **deepl**<br/>
   Purpose: **DeepL Text-to-Text translation**<br/>
-  Example: `deepl(src: "de", dst: "en-US")`<br/>
+  Example: `deepl(src: "de", dst: "en")`<br/>
   Notice: this node requires an API key!
 
   | Port    | Payload     |
@@ -198,11 +302,11 @@ Currently **SpeechFlow** provides the following processing nodes:
   | Parameter    | Position  | Default  | Requirement        |
   | ------------ | --------- | -------- | ------------------ |
   | **key**      | *none*    | env.SPEECHFLOW\_KEY\_DEEPL | *none* |
-  | **src**      | 0         | "de"     | `/^(?:de\|en-US)$/` |
-  | **dst**      | 1         | "en-US"  | `/^(?:de\|en-US)$/` |
+  | **src**      | 0         | "de"     | `/^(?:de\|en)$/` |
+  | **dst**      | 1         | "en"     | `/^(?:de\|en)$/` |
 
 - Node: **gemma**<br/>
-  Purpose: **Google Gemma Text-to-Text translation**<br/>
+  Purpose: **Google Gemma Text-to-Text translation and spelling correction**<br/>
   Example: `gemma(src: "de", dst: "en")`<br/>
   Notice; this node requires the Ollama API!
 
@@ -217,6 +321,48 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **src**      | 0         | "de"     | `/^(?:de\|en)$/` |
   | **dst**      | 1         | "en"     | `/^(?:de\|en)$/` |
 
+- Node: **opus**<br/>
+  Purpose: **OPUS Text-to-Text translation**<br/>
+  Example: `deepl(src: "de", dst: "en")`<br/>
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | text        |
+  | output  | text        |
+
+  | Parameter    | Position  | Default  | Requirement      |
+  | ------------ | --------- | -------- | ---------------- |
+  | **src**      | 0         | "de"     | `/^(?:de\|en)$/` |
+  | **dst**      | 1         | "en"     | `/^(?:de\|en)$/` |
+
+- Node: **subtitle**<br/>
+  Purpose: **SRT/VTT Subtitle Generation**<br/>
+  Example: `subtitle(format: "srt")`<br/>
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | text        |
+  | output  | text        |
+
+  | Parameter    | Position  | Default  | Requirement        |
+  | ------------ | --------- | -------- | ------------------ |
+  | **format**   | *none*    | "srt"    | /^(?:srt\|vtt)$/   |
+
+- Node: **format**<br/>
+  Purpose: **text paragraph formatting**<br/>
+  Example: `format(width: 80)`<br/>
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | text        |
+  | output  | text        |
+
+  | Parameter    | Position  | Default  | Requirement           |
+  | ------------ | --------- | -------- | --------------------- |
+  | **width**    | 0         | 80       | *none*                |
+
+### Text-to-Audio Nodes:
+
 - Node: **elevenlabs**<br/>
   Purpose: **ElevenLabs Text-to-Speech conversion**<br/>
   Example: `elevenlabs(language: "en")`<br/>
@@ -233,6 +379,22 @@ Currently **SpeechFlow** provides the following processing nodes:
   | **voice**    | 0         | "Brian"  | *none* |
   | **language** | 1         | "de"     | *none* |
 
+### Any-to-Any Nodes:
+
+- Node: **trace**<br/>
+  Purpose: **data flow tracing**<br/>
+  Example: `trace(type: "audio")`<br/>
+
+  | Port    | Payload     |
+  | ------- | ----------- |
+  | input   | text, audio |
+  | output  | text, audio |
+
+  | Parameter    | Position  | Default  | Requirement           |
+  | ------------ | --------- | -------- | --------------------- |
+  | **type**     | 0         | "audio"  | `/^(?:audio\|text)$/` |
+  | **name**     | 1         | *none*   | *none*                |
+
 Graph Expression Language
 -------------------------
 
@@ -266,13 +428,18 @@ number-value     ::= "0b" /[01]+/
 value            ::= "true" | "false" | "null" | "NaN" | "undefined"
 ```
 
+**SpeechFlow** makes available to **FlowLink** all **SpeechFlow** nodes as
+`node`, the CLI arguments under the array `variable` named `argv`, and all
+environment variables under the object `variable` named `env`.
+
 History
 -------
 
 **Speechflow**, as a technical cut-through, was initially created in
 March 2024 for use in the msg Filmstudio context. It was later refined
 into a more complete toolkit in April 2025 and this way the first time
-could be used in production.
+could be used in production. It was fully refactored in July 2025 in
+order to support timestamps in the streams processing.
 
 Copyright & License
 -------------------

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

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

package/dst/speechflow-node-a2a-ffmpeg.js

@@ -0,0 +1,152 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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"));
+const utils = __importStar(require("./speechflow-utils"));
+/*  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, cfg, opts, args) {
+        super(id, cfg, 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({
+            writable: streamInput,
+            readable: streamOutput
+        });
+        /*  wrap streams with conversions for chunk vs plain audio  */
+        const wrapper1 = utils.createTransformStreamForWritableSide();
+        const wrapper2 = utils.createTransformStreamForReadableSide("audio", () => this.timeZero);
+        this.stream = node_stream_1.default.compose(wrapper1, this.stream, wrapper2);
+    }
+    /*  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-a2a-wav.d.ts

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