speechflow 0.9.8 → 1.0.0

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

@@ -1,11 +0,0 @@
-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

@@ -1,170 +0,0 @@
-"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

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

package/dst/speechflow-node-websocket.js

@@ -1,275 +0,0 @@
-"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 ws_1 = __importDefault(require("ws"));
-const reconnecting_websocket_1 = __importDefault(require("@opensumi/reconnecting-websocket"));
-/*  internal dependencies  */
-const speechflow_node_1 = __importDefault(require("./speechflow-node"));
-const utils = __importStar(require("./speechflow-utils"));
-/*  SpeechFlow node for Websocket networking  */
-class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
-    /*  declare official node name  */
-    static name = "websocket";
-    /*  internal state  */
-    server = null;
-    client = null;
-    /*  construct node  */
-    constructor(id, cfg, opts, args) {
-        super(id, cfg, opts, args);
-        /*  declare node configuration parameters  */
-        this.configure({
-            listen: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+))$/ },
-            connect: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/ },
-            mode: { type: "string", val: "r", match: /^(?:r|w|rw)$/ },
-            type: { type: "string", val: "text", match: /^(?:audio|text)$/ }
-        });
-        /*  sanity check usage  */
-        if (this.params.listen !== "" && this.params.connect !== "")
-            throw new Error("Websocket node cannot listen and connect at the same time");
-        else if (this.params.listen === "" && this.params.connect === "")
-            throw new Error("Websocket node requires either listen or connect mode");
-        /*  declare node input/output format  */
-        if (this.params.mode === "rw") {
-            this.input = this.params.type;
-            this.output = this.params.type;
-        }
-        else if (this.params.mode === "r") {
-            this.input = "none";
-            this.output = this.params.type;
-        }
-        else if (this.params.mode === "w") {
-            this.input = this.params.type;
-            this.output = "none";
-        }
-    }
-    /*  open node  */
-    async open() {
-        if (this.params.listen !== "") {
-            /*  listen locally on a Websocket port  */
-            const url = new URL(this.params.listen);
-            const websockets = new Set();
-            const chunkQueue = new utils.SingleQueue();
-            const server = new ws_1.default.WebSocketServer({
-                host: url.hostname,
-                port: Number.parseInt(url.port),
-                path: url.pathname
-            });
-            server.on("listening", () => {
-                this.log("info", `listening on URL ${this.params.listen}`);
-            });
-            server.on("connection", (ws, request) => {
-                const peer = `${request.socket.remoteAddress}:${request.socket.remotePort}`;
-                this.log("info", `connection opened on URL ${this.params.listen} by peer ${peer}`);
-                websockets.add(ws);
-                ws.on("close", () => {
-                    this.log("info", `connection closed on URL ${this.params.listen} by peer ${peer}`);
-                    websockets.delete(ws);
-                });
-                ws.on("error", (error) => {
-                    this.log("error", `error of connection on URL ${this.params.listen} for peer ${peer}: ${error.message}`);
-                });
-                ws.on("message", (data, isBinary) => {
-                    if (this.params.mode === "w") {
-                        this.log("warning", `connection on URL ${this.params.listen} by peer ${peer}: ` +
-                            "received remote data on write-only node");
-                        return;
-                    }
-                    if (!isBinary) {
-                        this.log("warning", `connection on URL ${this.params.listen} by peer ${peer}: ` +
-                            "received non-binary message");
-                        return;
-                    }
-                    let buffer;
-                    if (Buffer.isBuffer(data))
-                        buffer = data;
-                    else if (data instanceof ArrayBuffer)
-                        buffer = Buffer.from(data);
-                    else
-                        buffer = Buffer.concat(data);
-                    const chunk = utils.streamChunkDecode(buffer);
-                    chunkQueue.write(chunk);
-                });
-            });
-            server.on("error", (error) => {
-                this.log("error", `error of some connection on URL ${this.params.listen}: ${error.message}`);
-            });
-            const type = this.params.type;
-            const mode = this.params.mode;
-            this.stream = new node_stream_1.default.Duplex({
-                writableObjectMode: true,
-                readableObjectMode: true,
-                decodeStrings: false,
-                write(chunk, encoding, callback) {
-                    if (mode === "r")
-                        callback(new Error("write operation on read-only node"));
-                    else if (chunk.type !== type)
-                        callback(new Error(`written chunk is not of ${type} type`));
-                    else if (websockets.size === 0)
-                        callback(new Error("still no Websocket connections available"));
-                    else {
-                        const data = utils.streamChunkEncode(chunk);
-                        const results = [];
-                        for (const websocket of websockets.values()) {
-                            results.push(new Promise((resolve, reject) => {
-                                websocket.send(data, (error) => {
-                                    if (error)
-                                        reject(error);
-                                    else
-                                        resolve();
-                                });
-                            }));
-                        }
-                        Promise.all(results).then(() => {
-                            callback();
-                        }).catch((errors) => {
-                            const error = new Error(errors.map((e) => e.message).join("; "));
-                            callback(error);
-                        });
-                    }
-                },
-                read(size) {
-                    if (mode === "w")
-                        throw new Error("read operation on write-only node");
-                    chunkQueue.read().then((chunk) => {
-                        this.push(chunk, "binary");
-                    });
-                }
-            });
-        }
-        else if (this.params.connect !== "") {
-            /*  connect remotely to a Websocket port  */
-            this.client = new reconnecting_websocket_1.default(this.params.connect, [], {
-                WebSocket: ws_1.default,
-                WebSocketOptions: {},
-                reconnectionDelayGrowFactor: 1.3,
-                maxReconnectionDelay: 4000,
-                minReconnectionDelay: 1000,
-                connectionTimeout: 4000,
-                minUptime: 5000
-            });
-            this.client.addEventListener("open", (ev) => {
-                this.log("info", `connection opened to URL ${this.params.connect}`);
-            });
-            this.client.addEventListener("close", (ev) => {
-                this.log("info", `connection closed to URL ${this.params.connect}`);
-            });
-            this.client.addEventListener("error", (ev) => {
-                this.log("error", `error of connection on URL ${this.params.connect}: ${ev.error.message}`);
-            });
-            const chunkQueue = new utils.SingleQueue();
-            this.client.addEventListener("message", (ev) => {
-                if (this.params.mode === "w") {
-                    this.log("warning", `connection to URL ${this.params.listen}: ` +
-                        "received remote data on write-only node");
-                    return;
-                }
-                if (!(ev.data instanceof ArrayBuffer)) {
-                    this.log("warning", `connection to URL ${this.params.listen}: ` +
-                        "received non-binary message");
-                    return;
-                }
-                const buffer = Buffer.from(ev.data);
-                const chunk = utils.streamChunkDecode(buffer);
-                chunkQueue.write(chunk);
-            });
-            const client = this.client;
-            client.binaryType = "arraybuffer";
-            const type = this.params.type;
-            const mode = this.params.mode;
-            this.stream = new node_stream_1.default.Duplex({
-                writableObjectMode: true,
-                readableObjectMode: true,
-                decodeStrings: false,
-                write(chunk, encoding, callback) {
-                    if (mode === "r")
-                        callback(new Error("write operation on read-only node"));
-                    else if (chunk.type !== type)
-                        callback(new Error(`written chunk is not of ${type} type`));
-                    else if (!client.OPEN)
-                        callback(new Error("still no Websocket connection available"));
-                    const data = utils.streamChunkEncode(chunk);
-                    client.send(data);
-                    callback();
-                },
-                read(size) {
-                    if (mode === "w")
-                        throw new Error("read operation on write-only node");
-                    if (!client.OPEN)
-                        throw new Error("still no Websocket connection available");
-                    chunkQueue.read().then((chunk) => {
-                        this.push(chunk, "binary");
-                    });
-                }
-            });
-        }
-    }
-    /*  close node  */
-    async close() {
-        /*  close Websocket server  */
-        if (this.server !== null) {
-            await new Promise((resolve, reject) => {
-                this.server.close((error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
-            });
-            this.server = null;
-        }
-        /*  close Websocket client  */
-        if (this.client !== null) {
-            this.client.close();
-            this.client = null;
-        }
-        /*  close stream  */
-        if (this.stream !== null) {
-            this.stream.destroy();
-            this.stream = null;
-        }
-    }
-}
-exports.default = SpeechFlowNodeWebsocket;

package/dst/speechflow-node-whisper-common.d.ts

@@ -1,34 +0,0 @@
-export type TranscriptionTaskRequest = {
-    type: "intermediate" | "final";
-    id: number;
-    language: string;
-    audio: Float32Array;
-};
-export type TranscriptionTaskResponse = {
-    type: "intermediate" | "final";
-    id: number;
-    language: string;
-    text: string;
-};
-export type WorkerRequest = {
-    type: "open";
-    cacheDir: string;
-    model: string;
-} | {
-    type: "task-request";
-    task: TranscriptionTaskRequest;
-} | {
-    type: "close";
-};
-export type WorkerResponse = {
-    type: "log";
-    message: string;
-} | {
-    type: "error";
-    message: string;
-} | {
-    type: "ok";
-} | {
-    type: "task-response";
-    task: TranscriptionTaskResponse;
-};

package/dst/speechflow-node-whisper-common.js

@@ -1,7 +0,0 @@
-"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>
-*/
-Object.defineProperty(exports, "__esModule", { value: true });

package/dst/speechflow-node-whisper-ggml.d.ts

@@ -1 +0,0 @@
-export {};

package/dst/speechflow-node-whisper-ggml.js

@@ -1,97 +0,0 @@
-"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_worker_threads_1 = __importDefault(require("node:worker_threads"));
-/*  external dependencies  */
-const smart_whisper_1 = require("smart-whisper");
-/*  utility function for sending a log message  */
-const log = (message) => node_worker_threads_1.default.parentPort.postMessage({ type: "log", message });
-/*  internal state  */
-let whisper = null;
-/*  OpenAI Whisper models (GGML variants for Whisper.cpp)  */
-const models = {
-    "v1-tiny": { model: "tiny" },
-    "v1-base": { model: "base" },
-    "v1-small": { model: "small" },
-    "v1-medium": { model: "medium" },
-    "v2-large": { model: "large-v2" },
-    "v3-large": { model: "large-v3" },
-    "v3-large-turbo": { model: "large-v3-turbo" }
-};
-/*  thread communication hook  */
-node_worker_threads_1.default.parentPort?.on("message", async (request) => {
-    let response = null;
-    if (request.type === "open") {
-        /*  initialize Whisper  */
-        const model = models[request.model]?.model;
-        if (!model)
-            response = { type: "error", message: `unknown Whisper model "${request.model}"` };
-        else {
-            log(`loading Whisper model "${request.model}": BEGIN`);
-            const name = await smart_whisper_1.manager.download(model);
-            const resolved = smart_whisper_1.manager.resolve(name);
-            whisper = new smart_whisper_1.Whisper(resolved, {
-                gpu: true,
-                offload: 120 * 60
-            });
-            if (whisper === null) {
-                log(`loading Whisper model "${request.model}": FAILED`);
-                response = { type: "error", message: "failed to open Whisper" };
-            }
-            else {
-                await whisper.load();
-                log(`loading Whisper model "${request.model}": SUCCESS`);
-                response = { type: "ok" };
-            }
-        }
-    }
-    else if (request.type === "task-request") {
-        log(`${request.task.type} transcription task ${request.task.id}": START`);
-        const task = await whisper.transcribe(request.task.audio, {
-            language: request.task.language,
-            n_threads: 16,
-            no_timestamps: false,
-            speed_up: true,
-            suppress_non_speech_tokens: true,
-            suppress_blank: true,
-            debug_mode: false,
-            print_special: false,
-            print_progress: false,
-            print_realtime: false,
-            print_timestamps: false
-        });
-        task.on("transcribed", (result) => {
-            console.log("TRANSCRIBED", JSON.stringify(result));
-        });
-        const result = await task.result;
-        log(`${request.task.type} transcription task ${request.task.id}": END`);
-        console.log("RESULT", result);
-        const text = result[0].text;
-        const taskResponse = {
-            type: request.task.type,
-            id: request.task.id,
-            language: request.task.language,
-            text: text ?? ""
-        };
-        response = { type: "task-response", task: taskResponse };
-    }
-    else if (request.type === "close") {
-        /*  shutdown Whisper  */
-        if (whisper !== null) {
-            log("unloading Whisper model: BEGIN");
-            await whisper.free();
-            whisper = null;
-            log("unloading Whisper model: END");
-        }
-    }
-    if (response !== null)
-        node_worker_threads_1.default.parentPort.postMessage(response);
-});

package/dst/speechflow-node-whisper-onnx.d.ts

@@ -1 +0,0 @@
-export {};