speechflow 0.9.4 → 0.9.7

package/dst/speechflow-node-websocket.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 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  */
@@ -23,12 +57,13 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
     server = null;
     client = 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({
             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  */
@@ -37,11 +72,15 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
         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.listen !== "") {
+        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.connect !== "") {
+        else if (this.params.mode === "w") {
             this.input = this.params.type;
             this.output = "none";
         }
@@ -51,7 +90,8 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
         if (this.params.listen !== "") {
             /*  listen locally on a Websocket port  */
             const url = new URL(this.params.listen);
-            let websocket = null;
+            const websockets = new Set();
+            const chunkQueue = new utils.SingleQueue();
             const server = new ws_1.default.WebSocketServer({
                 host: url.hostname,
                 port: Number.parseInt(url.port),
@@ -61,40 +101,81 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                 this.log("info", `listening on URL ${this.params.listen}`);
             });
             server.on("connection", (ws, request) => {
-                this.log("info", `connection opened on URL ${this.params.listen}`);
-                websocket = ws;
-            });
-            server.on("close", () => {
-                this.log("info", `connection closed on URL ${this.params.listen}`);
-                websocket = null;
+                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 on URL ${this.params.listen}: ${error.message}`);
-                websocket = null;
+                this.log("error", `error of some connection on URL ${this.params.listen}: ${error.message}`);
             });
-            const textEncoding = this.config.textEncoding;
+            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) {
-                    const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
-                    if (websocket !== null) {
-                        websocket.send(data, (error) => {
-                            if (error)
-                                callback(error);
-                            else
-                                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);
                         });
                     }
-                    else
-                        callback(new Error("still no Websocket connection available"));
                 },
                 read(size) {
-                    if (websocket !== null) {
-                        websocket.once("message", (data, isBinary) => {
-                            this.push(data, isBinary ? "binary" : textEncoding);
-                        });
-                    }
-                    else
-                        throw new Error("still no Websocket connection available");
+                    if (mode === "w")
+                        throw new Error("read operation on write-only node");
+                    chunkQueue.read().then((chunk) => {
+                        this.push(chunk, "binary");
+                    });
                 }
             });
         }
@@ -110,38 +191,57 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                 minUptime: 5000
             });
             this.client.addEventListener("open", (ev) => {
-                this.log("info", `connection opened on URL ${this.params.connect}`);
+                this.log("info", `connection opened to URL ${this.params.connect}`);
             });
             this.client.addEventListener("close", (ev) => {
-                this.log("info", `connection closed on URL ${this.params.connect}`);
+                this.log("info", `connection closed to URL ${this.params.connect}`);
             });
             this.client.addEventListener("error", (ev) => {
-                this.log("error", `error on URL ${this.params.connect}: ${ev.error.message}`);
+                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 textEncoding = this.config.textEncoding;
+            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) {
-                    const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
-                    if (client.OPEN) {
-                        client.send(data);
-                        callback();
-                    }
-                    else
+                    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 (client.OPEN) {
-                        client.addEventListener("message", (ev) => {
-                            if (ev.data instanceof ArrayBuffer)
-                                this.push(ev.data, "binary");
-                            else
-                                this.push(ev.data, textEncoding);
-                        }, { once: true });
-                    }
-                    else
+                    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");
+                    });
                 }
             });
         }

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

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

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

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

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

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

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

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

@@ -0,0 +1,131 @@
+"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_worker_threads_1 = __importDefault(require("node:worker_threads"));
+/*  external dependencies  */
+const Transformers = __importStar(require("@huggingface/transformers"));
+/*  utility function for sending a log message  */
+const log = (message) => node_worker_threads_1.default.parentPort.postMessage({ type: "log", message });
+/*  internal state  */
+let transcriber = null;
+/*  OpenAI Whisper models (ONNX variants)  */
+const models = {
+    "v1-tiny": { model: "onnx-community/whisper-tiny-ONNX" },
+    "v1-base": { model: "onnx-community/whisper-base" },
+    "v1-small": { model: "onnx-community/whisper-small" },
+    "v1-medium": { model: "onnx-community/whisper-medium-ONNX" },
+    "v2-large": { model: "reach-vb/whisper-large-v2-onnx" },
+    "v3-large": { model: "onnx-community/whisper-large-v3-ONNX" },
+    "v3-large-turbo": { model: "onnx-community/whisper-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`);
+            transcriber = await Transformers.pipeline("automatic-speech-recognition", model, {
+                cache_dir: node_path_1.default.join(request.cacheDir, "whisper"),
+                dtype: "q4",
+                device: "gpu"
+            });
+            if (transcriber === null) {
+                log(`loading Whisper model "${request.model}": FAILED`);
+                response = { type: "error", message: "failed to open Whisper" };
+            }
+            else {
+                log(`loading Whisper model "${request.model}": SUCCESS`);
+                response = { type: "ok" };
+            }
+        }
+    }
+    else if (request.type === "task-request") {
+        /*  perform a speech-to-text transcription with Whisper  */
+        /*
+        const streamer = new Transformers.TextStreamer(transcriber!.tokenizer, {
+            skip_prompt: true,
+            callback_function: (text) => {
+                console.log("TEXT", text)
+            }
+        })
+        */
+        log(`${request.task.type} transcription task ${request.task.id}": START`);
+        const result = await transcriber(request.task.audio, {
+            chunk_length_s: 3,
+            stride_length_s: 1,
+            language: request.task.language,
+            task: "transcribe",
+            force_full_sequences: false,
+            use_cache: true,
+            return_timestamps: true,
+            // streamer
+        });
+        log(`${request.task.type} transcription task ${request.task.id}": END`);
+        console.log("RESULT", JSON.stringify(result));
+        const text = Array.isArray(result) ? result[0].text : result.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 (transcriber !== null) {
+            log("unloading Whisper model: BEGIN");
+            await transcriber.dispose();
+            transcriber = null;
+            log("unloading Whisper model: END");
+        }
+    }
+    if (response !== null)
+        node_worker_threads_1.default.parentPort.postMessage(response);
+});

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

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

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

@@ -0,0 +1,97 @@
+"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-worker-onnx.d.ts

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