speechflow 0.9.4 → 0.9.7

package/dst/speechflow-node-t2t-opus.js

@@ -0,0 +1,135 @@
+"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_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
+const Transformers = __importStar(require("@huggingface/transformers"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for OPUS text-to-text translation  */
+class SpeechFlowNodeOPUS extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "opus";
+    /*  internal state  */
+    translator = 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: "de", match: /^(?:de|en)$/ },
+            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ }
+        });
+        /*  sanity check situation  */
+        if (this.params.src === this.params.dst)
+            throw new Error("source and destination languages cannot be the same");
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        /*  instantiate OPUS  */
+        const model = `onnx-community/opus-mt-${this.params.src}-${this.params.dst}`;
+        this.translator = await Transformers.pipeline("translation", model, {
+            cache_dir: node_path_1.default.join(this.config.cacheDir, "opus"),
+            dtype: "q4",
+            device: "gpu"
+        });
+        if (this.translator === null)
+            throw new Error("failed to instantiate translator pipeline");
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            const result = await this.translator(text);
+            return Array.isArray(result) ?
+                result[0].translation_text :
+                result.translation_text;
+        };
+        /*  establish a duplex stream and connect it to Ollama  */
+        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 {
+                        translate(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();
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+        /*  shutdown OPUS  */
+        if (this.translator !== null) {
+            this.translator.dispose();
+            this.translator = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeOPUS;

package/dst/speechflow-node-t2t-subtitle.d.ts

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

package/dst/speechflow-node-t2t-subtitle.js

@@ -0,0 +1,96 @@
+"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"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for subtitle (text-to-text) "translations"  */
+class SpeechFlowNodeSubtitle extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "subtitle";
+    /*  internal state  */
+    sequenceNo = 1;
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            format: { type: "string", pos: 0, val: "srt", match: /^(?:srt|vtt)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        this.sequenceNo = 1;
+        /*  provide text-to-subtitle conversion  */
+        const convert = async (chunk) => {
+            if (typeof chunk.payload !== "string")
+                throw new Error("chunk payload type must be string");
+            let text = chunk.payload;
+            if (this.params.format === "srt") {
+                const start = chunk.timestampStart.toFormat("hh:mm:ss,SSS");
+                const end = chunk.timestampEnd.toFormat("hh:mm:ss,SSS");
+                text = `${this.sequenceNo++}\n` +
+                    `${start} --> ${end}\n` +
+                    `${text}\n\n`;
+            }
+            else if (this.params.format === "vtt") {
+                const start = chunk.timestampStart.toFormat("hh:mm:ss.SSS");
+                const end = chunk.timestampEnd.toFormat("hh:mm:ss.SSS");
+                text = `${this.sequenceNo++}\n` +
+                    `${start} --> ${end}\n` +
+                    `${text}\n\n`;
+            }
+            return text;
+        };
+        /*  establish a duplex stream  */
+        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 {
+                        convert(chunk).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 = SpeechFlowNodeSubtitle;

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

@@ -0,0 +1,11 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeTrace 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-trace.js

@@ -0,0 +1,88 @@
+"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"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for data flow tracing  */
+class SpeechFlowNodeTrace extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "trace";
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            type: { type: "string", pos: 0, val: "audio", match: /^(?:audio|text)$/ },
+            name: { type: "string", pos: 1 }
+        });
+        /*  declare node input/output format  */
+        this.input = this.params.type;
+        this.output = this.params.type;
+    }
+    /*  open node  */
+    async open() {
+        /*  wrapper for local logging  */
+        const log = (level, msg) => {
+            if (this.params.name !== undefined)
+                this.log(level, `[${this.params.name}]: ${msg}`);
+            else
+                this.log(level, msg);
+        };
+        /*  provide Duplex stream and internally attach to Deepgram API  */
+        const type = this.params.type;
+        this.stream = new node_stream_1.default.Transform({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, encoding, callback) {
+                let error;
+                const fmt = (t) => t.toFormat("hh:mm:ss.SSS");
+                if (Buffer.isBuffer(chunk.payload)) {
+                    if (type === "audio")
+                        log("info", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
+                            `end=${fmt(chunk.timestampEnd)} kind=${chunk.kind} type=${chunk.type} ` +
+                            `payload-type=Buffer payload-bytes=${chunk.payload.byteLength}`);
+                    else
+                        error = new Error(`writing ${type} chunk: seen Buffer instead of String chunk type`);
+                }
+                else {
+                    if (type === "text")
+                        log("info", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
+                            `end=${fmt(chunk.timestampEnd)} kind=${chunk.kind} type=${chunk.type}` +
+                            `payload-type=String payload-length=${chunk.payload.length} ` +
+                            `payload-encoding=${encoding} payload-content="${chunk.payload.toString()}"`);
+                    else
+                        error = new Error(`writing ${type} chunk: seen String instead of Buffer chunk type`);
+                }
+                if (error !== undefined)
+                    callback(error);
+                else {
+                    this.push(chunk, encoding);
+                    callback();
+                }
+            },
+            final(callback) {
+                this.push(null);
+                callback();
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeTrace;

package/dst/speechflow-node-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>;
+}

package/dst/speechflow-node-wav.js

@@ -0,0 +1,170 @@
+"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 wav_1 = __importDefault(require("wav"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+const utils = __importStar(require("./speechflow-utils"));
+/*  utility class for wrapping a custom stream into a regular Transform stream  */
+class StreamWrapper extends node_stream_1.default.Transform {
+    foreignStream;
+    constructor(foreignStream, options = {}) {
+        options.readableObjectMode = true;
+        options.writableObjectMode = true;
+        super(options);
+        this.foreignStream = foreignStream;
+        this.foreignStream.on("data", (chunk) => {
+            this.push(chunk);
+        });
+        this.foreignStream.on("error", (err) => {
+            this.emit("error", err);
+        });
+        this.foreignStream.on("end", () => {
+            this.push(null);
+        });
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            const canContinue = this.foreignStream.write(chunk);
+            if (canContinue)
+                callback();
+            else
+                this.foreignStream.once("drain", callback);
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _flush(callback) {
+        try {
+            if (typeof this.foreignStream.end === "function")
+                this.foreignStream.end();
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+/*  SpeechFlow node for WAV format conversion  */
+class SpeechFlowNodeWAV extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "wav";
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            mode: { type: "string", pos: 1, val: "encode", match: /^(?:encode|decode)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "audio";
+        this.output = "audio";
+    }
+    /*  open node  */
+    async open() {
+        if (this.params.mode === "encode") {
+            /*  convert raw/PCM to WAV/PCM  */
+            /*  NOTICE: as this is a continuous stream, the resulting WAV header is not 100%
+                conforming to the WAV standard, as it has to use a zero duration information.
+                This cannot be changed in a stream-based processing.  */
+            const writer = new wav_1.default.Writer({
+                format: 0x0001 /* PCM */,
+                channels: this.config.audioChannels,
+                sampleRate: this.config.audioSampleRate,
+                bitDepth: this.config.audioBitDepth
+            });
+            this.stream = new StreamWrapper(writer);
+        }
+        else if (this.params.mode === "decode") {
+            /*  convert WAV/PCM to raw/PCM  */
+            const reader = new wav_1.default.Reader();
+            reader.on("format", (format) => {
+                this.log("info", `WAV audio stream: format=${format.audioFormat === 0x0001 ? "PCM" :
+                    "0x" + format.audioFormat.toString(16).padStart(4, "0")} ` +
+                    `bitDepth=${format.bitDepth} ` +
+                    `signed=${format.signed ? "yes" : "no"} ` +
+                    `endian=${format.endianness} ` +
+                    `sampleRate=${format.sampleRate} ` +
+                    `channels=${format.channels}`);
+                if (format.audioFormat !== 0x0001 /* PCM */)
+                    throw new Error("WAV not based on PCM format");
+                if (format.bitDepth !== 16)
+                    throw new Error("WAV not based on 16 bit samples");
+                if (!format.signed)
+                    throw new Error("WAV not based on signed integers");
+                if (format.endianness !== "LE")
+                    throw new Error("WAV not based on little endianness");
+                if (format.sampleRate !== 48000)
+                    throw new Error("WAV not based on 48Khz sample rate");
+                if (format.channels !== 1)
+                    throw new Error("WAV not based on mono channel");
+            });
+            this.stream = new StreamWrapper(reader);
+        }
+        else
+            throw new Error(`invalid operation mode "${this.params.mode}"`);
+        /*  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);
+    }
+    /*  close node  */
+    async close() {
+        /*  shutdown 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;
+        }
+    }
+}
+exports.default = SpeechFlowNodeWAV;

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

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