speechflow 0.9.4 → 0.9.7

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

@@ -2,7 +2,9 @@ import SpeechFlowNode from "./speechflow-node";
 export default class SpeechFlowNodeDevice extends SpeechFlowNode {
     static name: string;
     private io;
-    constructor(id: string, opts: {
+    constructor(id: string, cfg: {
+        [id: string]: any;
+    }, opts: {
         [id: string]: any;
     }, args: any[]);
     private audioDeviceFromURL;

package/dst/speechflow-node-device.js

@@ -4,14 +4,50 @@
 **  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 naudiodon_1 = __importDefault(require("@gpeng/naudiodon"));
 /*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+const utils = __importStar(require("./speechflow-utils"));
 /*  SpeechFlow node for device access  */
 class SpeechFlowNodeDevice extends speechflow_node_1.default {
     /*  declare official node name  */
@@ -19,8 +55,8 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
     /*  internal state  */
     io = null;
     /*  construct node  */
-    constructor(id, opts, args) {
-        super(id, opts, args);
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
         /*  declare node configuration parameters  */
         this.configure({
             device: { type: "string", pos: 0, match: /^(.+?):(.+)$/ },
@@ -54,6 +90,9 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
             throw new Error(`invalid audio API type "${type}"`);
         /*  determine device of audio API  */
         const devices = naudiodon_1.default.getDevices();
+        for (const device of devices)
+            this.log("info", `found audio device "${device.name}" ` +
+                `(inputs: ${device.maxInputChannels}, outputs: ${device.maxOutputChannels}`);
         const device = devices.find((device) => {
             return (((mode === "r" && device.maxInputChannels > 0)
                 || (mode === "w" && device.maxOutputChannels > 0)
@@ -102,6 +141,10 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
                 }
             });
             this.stream = this.io;
+            /*  convert regular stream into object-mode stream  */
+            const wrapper1 = utils.createTransformStreamForWritableSide();
+            const wrapper2 = utils.createTransformStreamForReadableSide("audio", () => this.timeZero);
+            this.stream = node_stream_1.default.compose(wrapper1, this.stream, wrapper2);
         }
         else if (this.params.mode === "r") {
             /*  input device  */
@@ -117,6 +160,10 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
                 }
             });
             this.stream = this.io;
+            /*  convert regular stream into object-mode stream  */
+            const wrapper = utils.createTransformStreamForReadableSide("audio", () => this.timeZero);
+            this.stream.pipe(wrapper);
+            this.stream = wrapper;
         }
         else if (this.params.mode === "w") {
             /*  output device  */
@@ -132,6 +179,10 @@ class SpeechFlowNodeDevice extends speechflow_node_1.default {
                 }
             });
             this.stream = this.io;
+            /*  convert regular stream into object-mode stream  */
+            const wrapper = utils.createTransformStreamForWritableSide();
+            wrapper.pipe(this.stream);
+            this.stream = wrapper;
         }
         else
             throw new Error(`device "${device.id}" does not have any input or output channels`);

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

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

package/dst/speechflow-node-elevenlabs.js

@@ -43,39 +43,29 @@ var __importDefault = (this && this.__importDefault) || function (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 ElevenLabs = __importStar(require("@elevenlabs/elevenlabs-js"));
 const get_stream_1 = require("get-stream");
+const speex_resampler_1 = __importDefault(require("speex-resampler"));
 /*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
-/*
-const elevenlabsVoices = {
-    "drew":    { name: "Drew",    model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
-    "george":  { name: "George",  model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
-    "bill":    { name: "Bill",    model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
-    "daniel":  { name: "Daniel",  model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
-    "brian":   { name: "Brian",   model: "eleven_turbo_v2",        lang: [ "en"       ] },
-    "sarah":   { name: "Sarah",   model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
-    "racel":   { name: "Racel",   model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
-    "grace":   { name: "Grace",   model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
-    "matilda": { name: "Matilda", model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
-    "alice":   { name: "Alice",   model: "eleven_turbo_v2",        lang: [ "en"       ] }
-}
-*/
+/*  SpeechFlow node for Elevenlabs text-to-speech conversion  */
 class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
     /*  declare official node name  */
     static name = "elevenlabs";
     /*  internal state  */
     elevenlabs = null;
+    static speexInitialized = false;
     /*  construct node  */
-    constructor(id, opts, args) {
-        super(id, opts, args);
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, 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 }
+            voice: { type: "string", val: "Brian", pos: 0, match: /^(?:.+)$/ },
+            language: { type: "string", val: "en", pos: 1, match: /^(?:de|en)$/ },
+            speed: { type: "number", val: 1.05, pos: 2, match: (n) => n >= 0.7 && n <= 1.2 },
+            optimize: { type: "string", val: "latency", pos: 3, match: /^(?:latency|quality)$/ }
         });
         /*  declare node input/output format  */
         this.input = "text";
@@ -83,51 +73,97 @@ class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
     }
     /*  open node  */
     async open() {
+        /*  establish ElevenLabs API connection  */
         this.elevenlabs = new ElevenLabs.ElevenLabsClient({
             apiKey: this.params.key
         });
+        /*  determine maximum sample rate of ElevenLabs tier  */
+        const maxSampleRates = {
+            "free": 16000,
+            "starter": 22050,
+            "creator": 24000,
+            "independent_publisher": 44100,
+            "growing_business": 44100,
+            "enterprise": 44100
+        };
+        const sub = await this.elevenlabs.user.subscription.get();
+        const tier = (sub.tier ?? "free");
+        this.log("info", `determined ElevenLabs tier: "${tier}"`);
+        let maxSampleRate = 16000;
+        if (maxSampleRates[tier] !== undefined)
+            maxSampleRate = maxSampleRates[tier];
+        this.log("info", `determined maximum audio sample rate: ${maxSampleRate}`);
+        /*  determine voice for text-to-speech operation
+            (for details see https://elevenlabs.io/text-to-speech)  */
         const voices = await this.elevenlabs.voices.getAll();
-        const voice = voices.voices.find((voice) => voice.name === this.params.voice);
-        if (voice === undefined)
-            throw new Error(`invalid ElevenLabs voice "${this.params.voice}"`);
+        let voice = voices.voices.find((voice) => voice.name === this.params.voice);
+        if (voice === undefined) {
+            voice = voices.voices.find((voice) => voice.name.startsWith(this.params.voice));
+            if (voice === undefined)
+                throw new Error(`invalid ElevenLabs voice "${this.params.voice}"`);
+        }
+        const info = Object.keys(voice.labels ?? {}).length > 0 ?
+            (", " + Object.entries(voice.labels)
+                .map(([key, val]) => `${key}: "${val}"`).join(", ")) : "";
+        this.log("info", `selected voice: name: "${voice.name}"${info}`);
+        /*  perform text-to-speech operation with Elevenlabs API  */
+        const model = this.params.optimize === "quality" ?
+            "eleven_multilingual_v2" :
+            "eleven_flash_v2_5";
         const speechStream = (text) => {
-            return this.elevenlabs.textToSpeech.convert(voice.voice_id, {
+            this.log("info", `ElevenLabs: send text "${text}"`);
+            return this.elevenlabs.textToSpeech.convert(voice.voiceId, {
                 text,
-                optimize_streaming_latency: 2,
-                output_format: "pcm_16000", // S16LE
-                model_id: "eleven_flash_v2_5",
-                /*
-                voice_settings: {
-                    stability: 0,
-                    similarity_boost: 0
+                modelId: model,
+                languageCode: this.params.language,
+                outputFormat: `pcm_${maxSampleRate}`,
+                seed: 815, /* arbitrary, but fixated by us */
+                voiceSettings: {
+                    speed: this.params.speed
                 }
-                */
             }, {
                 timeoutInSeconds: 30,
                 maxRetries: 10
             });
         };
-        const queue = new node_events_1.EventEmitter();
-        this.stream = new node_stream_1.default.Duplex({
-            write(chunk, encoding, callback) {
-                if (encoding !== "utf8" && encoding !== "utf-8")
-                    callback(new Error("only text input supported by Elevenlabs node"));
-                const data = chunk.toString();
-                speechStream(data).then((stream) => {
-                    (0, get_stream_1.getStreamAsBuffer)(stream).then((buffer) => {
-                        queue.emit("audio", buffer);
-                        callback();
+        /*  establish resampler from ElevenLabs's maximum 24Khz
+            output to our standard audio sample rate (48KHz)  */
+        if (!SpeechFlowNodeElevenlabs.speexInitialized) {
+            /*  at least once initialize resampler  */
+            await speex_resampler_1.default.initPromise;
+            SpeechFlowNodeElevenlabs.speexInitialized = true;
+        }
+        const resampler = new speex_resampler_1.default(1, maxSampleRate, this.config.audioSampleRate, 7);
+        /*  create transform stream and connect it to the ElevenLabs API  */
+        const log = (level, msg) => { this.log(level, msg); };
+        this.stream = new node_stream_1.default.Transform({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"));
+                else {
+                    speechStream(chunk.payload).then((stream) => {
+                        (0, get_stream_1.getStreamAsBuffer)(stream).then((buffer) => {
+                            const bufferResampled = resampler.processChunk(buffer);
+                            log("info", `ElevenLabs: received audio (buffer length: ${buffer.byteLength})`);
+                            const chunkNew = chunk.clone();
+                            chunkNew.type = "audio";
+                            chunkNew.payload = bufferResampled;
+                            this.push(chunkNew);
+                            callback();
+                        }).catch((error) => {
+                            callback(error);
+                        });
                     }).catch((error) => {
                         callback(error);
                     });
-                }).catch((error) => {
-                    callback(error);
-                });
+                }
             },
-            read(size) {
-                queue.once("audio", (buffer) => {
-                    this.push(buffer, "binary");
-                });
+            final(callback) {
+                this.push(null);
+                callback();
             }
         });
     }
@@ -138,6 +174,9 @@ class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
             this.stream.destroy();
             this.stream = null;
         }
+        /*  destroy ElevenLabs API  */
+        if (this.elevenlabs !== null)
+            this.elevenlabs = null;
     }
 }
 exports.default = SpeechFlowNodeElevenlabs;

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

@@ -3,7 +3,9 @@ export default class SpeechFlowNodeFFmpeg extends SpeechFlowNode {
     static name: string;
     private ffmpegBinary;
     private ffmpeg;
-    constructor(id: string, opts: {
+    constructor(id: string, cfg: {
+        [id: string]: any;
+    }, opts: {
         [id: string]: any;
     }, args: any[]);
     open(): Promise<void>;

package/dst/speechflow-node-ffmpeg.js

@@ -4,6 +4,39 @@
 **  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 };
 };
@@ -15,6 +48,7 @@ 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  */
@@ -23,8 +57,8 @@ class SpeechFlowNodeFFmpeg extends speechflow_node_1.default {
     ffmpegBinary = ffmpeg_1.default.supported ? ffmpeg_1.default.binary : "ffmpeg";
     ffmpeg = null;
     /*  construct node  */
-    constructor(id, opts, args) {
-        super(id, opts, args);
+    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)$/ },
@@ -87,9 +121,13 @@ class SpeechFlowNodeFFmpeg extends speechflow_node_1.default {
         this.ffmpeg.run();
         /*  establish a duplex stream and connect it to FFmpeg  */
         this.stream = node_stream_1.default.Duplex.from({
-            readable: streamOutput,
-            writable: streamInput
+            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() {

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

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

package/dst/speechflow-node-file.js

@@ -4,6 +4,39 @@
 **  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 };
 };
@@ -13,13 +46,14 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_stream_1 = __importDefault(require("node:stream"));
 /*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+const utils = __importStar(require("./speechflow-utils"));
 /*  SpeechFlow node for file access  */
 class SpeechFlowNodeFile extends speechflow_node_1.default {
     /*  declare official node name  */
     static name = "file";
     /*  construct node  */
-    constructor(id, opts, args) {
-        super(id, opts, args);
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
         /*  declare node configuration parameters  */
         this.configure({
             path: { type: "string", pos: 0 },
@@ -42,12 +76,17 @@ class SpeechFlowNodeFile extends speechflow_node_1.default {
     }
     /*  open node  */
     async open() {
-        const encoding = this.params.type === "text" ? this.config.textEncoding : "binary";
         if (this.params.mode === "rw") {
             if (this.params.path === "-") {
                 /*  standard I/O  */
-                process.stdin.setEncoding(encoding);
-                process.stdout.setEncoding(encoding);
+                if (this.params.type === "audio") {
+                    process.stdin.setEncoding();
+                    process.stdout.setEncoding();
+                }
+                else {
+                    process.stdin.setEncoding(this.config.textEncoding);
+                    process.stdout.setEncoding(this.config.textEncoding);
+                }
                 this.stream = node_stream_1.default.Duplex.from({
                     readable: process.stdin,
                     writable: process.stdout
@@ -55,33 +94,65 @@ class SpeechFlowNodeFile extends speechflow_node_1.default {
             }
             else {
                 /*  file I/O  */
-                this.stream = node_stream_1.default.Duplex.from({
-                    readable: node_fs_1.default.createReadStream(this.params.path, { encoding }),
-                    writable: node_fs_1.default.createWriteStream(this.params.path, { encoding })
-                });
+                if (this.params.type === "audio") {
+                    this.stream = node_stream_1.default.Duplex.from({
+                        readable: node_fs_1.default.createReadStream(this.params.path),
+                        writable: node_fs_1.default.createWriteStream(this.params.path)
+                    });
+                }
+                else {
+                    this.stream = node_stream_1.default.Duplex.from({
+                        readable: node_fs_1.default.createReadStream(this.params.path, { encoding: this.config.textEncoding }),
+                        writable: node_fs_1.default.createWriteStream(this.params.path, { encoding: this.config.textEncoding })
+                    });
+                }
             }
+            /*  convert regular stream into object-mode stream  */
+            const wrapper1 = utils.createTransformStreamForWritableSide();
+            const wrapper2 = utils.createTransformStreamForReadableSide(this.params.type, () => this.timeZero);
+            this.stream = node_stream_1.default.compose(wrapper1, this.stream, wrapper2);
         }
         else if (this.params.mode === "r") {
             if (this.params.path === "-") {
                 /*  standard I/O  */
-                process.stdin.setEncoding(encoding);
+                if (this.params.type === "audio")
+                    process.stdin.setEncoding();
+                else
+                    process.stdin.setEncoding(this.config.textEncoding);
                 this.stream = process.stdin;
             }
             else {
                 /*  file I/O  */
-                this.stream = node_fs_1.default.createReadStream(this.params.path, { encoding });
+                if (this.params.type === "audio")
+                    this.stream = node_fs_1.default.createReadStream(this.params.path);
+                else
+                    this.stream = node_fs_1.default.createReadStream(this.params.path, { encoding: this.config.textEncoding });
             }
+            /*  convert regular stream into object-mode stream  */
+            const wrapper = utils.createTransformStreamForReadableSide(this.params.type, () => this.timeZero);
+            this.stream.pipe(wrapper);
+            this.stream = wrapper;
         }
         else if (this.params.mode === "w") {
             if (this.params.path === "-") {
                 /*  standard I/O  */
-                process.stdout.setEncoding(encoding);
+                if (this.params.type === "audio")
+                    process.stdout.setEncoding();
+                else
+                    process.stdout.setEncoding(this.config.textEncoding);
                 this.stream = process.stdout;
             }
             else {
                 /*  file I/O  */
-                this.stream = node_fs_1.default.createWriteStream(this.params.path, { encoding });
+                if (this.params.type === "audio")
+                    this.stream = node_fs_1.default.createWriteStream(this.params.path);
+                else
+                    this.stream = node_fs_1.default.createWriteStream(this.params.path, { encoding: this.config.textEncoding });
             }
+            /*  convert regular stream into object-mode stream  */
+            const wrapper = utils.createTransformStreamForWritableSide();
+            wrapper.pipe(this.stream);
+            this.stream = wrapper;
         }
         else
             throw new Error(`invalid file mode "${this.params.mode}"`);

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

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

package/dst/speechflow-node-format.js

@@ -0,0 +1,80 @@
+"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 wrap_text_1 = __importDefault(require("wrap-text"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for text-to-text formatting  */
+class SpeechFlowNodeFormat extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "format";
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            width: { type: "number", val: 80 }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        /*  provide text-to-text formatter  */
+        const format = async (text) => {
+            text = (0, wrap_text_1.default)(text, this.params.width);
+            text = text.replace(/([^\n])$/, "$1\n");
+            return text;
+        };
+        /*  establish a duplex stream and connect it to DeepL translation  */
+        this.stream = new node_stream_1.default.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"));
+                else {
+                    if (chunk.payload === "") {
+                        this.push(chunk);
+                        callback();
+                    }
+                    else {
+                        format(chunk.payload).then((payload) => {
+                            const chunkNew = chunk.clone();
+                            chunkNew.payload = payload;
+                            this.push(chunkNew);
+                            callback();
+                        }).catch((err) => {
+                            callback(err);
+                        });
+                    }
+                }
+            },
+            final(callback) {
+                this.push(null);
+                callback();
+            }
+        });
+    }
+    /*  open node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeFormat;