speechflow 0.9.5 → 0.9.7

package/dst/speechflow-node-xio-mqtt.js

@@ -0,0 +1,181 @@
+"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 mqtt_1 = __importDefault(require("mqtt"));
+const pure_uuid_1 = __importDefault(require("pure-uuid"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+const utils = __importStar(require("./speechflow-utils"));
+/*  SpeechFlow node for MQTT networking  */
+class SpeechFlowNodeMQTT extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "mqtt";
+    /*  internal state  */
+    broker = null;
+    clientId = (new pure_uuid_1.default(1)).format();
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            url: { type: "string", pos: 0, val: "", match: /^(?:|(?:ws|mqtt):\/\/(.+?):(\d+)(?:\/.*)?)$/ },
+            username: { type: "string", pos: 1, val: "", match: /^.+$/ },
+            password: { type: "string", pos: 2, val: "", match: /^.+$/ },
+            topicRead: { type: "string", pos: 3, val: "", match: /^.+$/ },
+            topicWrite: { type: "string", pos: 4, val: "", match: /^.+$/ },
+            mode: { type: "string", pos: 5, val: "w", match: /^(?:r|w|rw)$/ },
+            type: { type: "string", pos: 6, val: "text", match: /^(?:audio|text)$/ }
+        });
+        /*  logical parameter sanity check  */
+        if ((this.params.mode === "w" || this.params.mode === "rw") && this.params.topicWrite === "")
+            throw new Error("writing to MQTT requires a topicWrite parameter");
+        if ((this.params.mode === "r" || this.params.mode === "rw") && this.params.topicRead === "")
+            throw new Error("reading from MQTT requires a topicRead parameter");
+        /*  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() {
+        /*  connect remotely to a MQTT broker  */
+        this.broker = mqtt_1.default.connect(this.params.url, {
+            protocolId: "MQTT",
+            protocolVersion: 5,
+            username: this.params.username,
+            password: this.params.password,
+            clientId: this.clientId,
+            clean: true,
+            resubscribe: true,
+            keepalive: 60, /* 60s */
+            reconnectPeriod: 2 * 1000, /*  2s */
+            connectTimeout: 30 * 1000 /* 30s */
+        });
+        this.broker.on("error", (error) => {
+            this.log("error", `error on MQTT ${this.params.url}: ${error.message}`);
+        });
+        this.broker.on("connect", (packet) => {
+            this.log("info", `connection opened to MQTT ${this.params.url}`);
+            if (this.params.mode !== "w" && !packet.sessionPresent)
+                this.broker.subscribe([this.params.topicRead], () => { });
+        });
+        this.broker.on("reconnect", () => {
+            this.log("info", `connection re-opened to MQTT ${this.params.url}`);
+        });
+        this.broker.on("disconnect", (packet) => {
+            this.log("info", `connection closed to MQTT ${this.params.url}`);
+        });
+        const chunkQueue = new utils.SingleQueue();
+        this.broker.on("message", (topic, payload, packet) => {
+            if (topic !== this.params.topicRead)
+                return;
+            try {
+                const chunk = utils.streamChunkDecode(payload);
+                chunkQueue.write(chunk);
+            }
+            catch (_err) {
+                this.log("warning", `received invalid CBOR chunk from MQTT ${this.params.url}`);
+            }
+        });
+        const broker = this.broker;
+        const topicWrite = this.params.topicWrite;
+        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 (!broker.connected)
+                    callback(new Error("still no MQTT connection available"));
+                else {
+                    const data = Buffer.from(utils.streamChunkEncode(chunk));
+                    broker.publish(topicWrite, data, { qos: 2, retain: false }, (err) => {
+                        if (err)
+                            callback(new Error(`failed to publish to MQTT topic "${topicWrite}": ${err}`));
+                        else
+                            callback();
+                    });
+                }
+            },
+            read(size) {
+                if (mode === "w")
+                    throw new Error("read operation on write-only node");
+                chunkQueue.read().then((chunk) => {
+                    this.push(chunk, "binary");
+                });
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close Websocket server  */
+        if (this.broker !== null) {
+            if (this.broker.connected)
+                this.broker.end();
+            this.broker = null;
+        }
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeMQTT;

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

@@ -0,0 +1,13 @@
+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-xio-websocket.js

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

@@ -1,15 +1,27 @@
 import Events from "node:events";
 import Stream from "node:stream";
+import { DateTime, Duration } from "luxon";
+export declare class SpeechFlowChunk {
+    timestampStart: Duration;
+    timestampEnd: Duration;
+    kind: "intermediate" | "final";
+    type: "audio" | "text";
+    payload: Buffer | string;
+    constructor(timestampStart: Duration, timestampEnd: Duration, kind: "intermediate" | "final", type: "audio" | "text", payload: Buffer | string);
+    clone(): SpeechFlowChunk;
+}
 export default class SpeechFlowNode extends Events.EventEmitter {
     id: string;
+    private cfg;
     private opts;
     private args;
     config: {
-        readonly audioChannels: 1;
-        readonly audioBitDepth: 16;
-        readonly audioLittleEndian: true;
-        readonly audioSampleRate: 48000;
-        readonly textEncoding: "utf8";
+        audioChannels: number;
+        audioBitDepth: (1 | 8 | 16 | 24 | 32);
+        audioLittleEndian: boolean;
+        audioSampleRate: number;
+        textEncoding: BufferEncoding;
+        cacheDir: string;
     };
     input: string;
     output: string;
@@ -19,9 +31,15 @@ export default class SpeechFlowNode extends Events.EventEmitter {
     stream: Stream.Writable | Stream.Readable | Stream.Duplex | null;
     connectionsIn: Set<SpeechFlowNode>;
     connectionsOut: Set<SpeechFlowNode>;
-    constructor(id: string, opts: {
+    timeOpen: DateTime<boolean> | undefined;
+    timeZero: DateTime<boolean>;
+    timeZeroOffset: Duration<boolean>;
+    constructor(id: string, cfg: {
+        [id: string]: any;
+    }, opts: {
         [id: string]: any;
     }, args: any[]);
+    setTimeZero(time: DateTime): void;
     configure(spec: {
         [id: string]: {
             type: string;

package/dst/speechflow-node.js

@@ -8,20 +8,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechFlowChunk = void 0;
 /*  standard dependencies  */
 const node_events_1 = __importDefault(require("node:events"));
+const luxon_1 = require("luxon");
+/*  the definition of a single payload chunk passed through the SpeechFlow nodes  */
+class SpeechFlowChunk {
+    timestampStart;
+    timestampEnd;
+    kind;
+    type;
+    payload;
+    constructor(timestampStart, timestampEnd, kind, type, payload) {
+        this.timestampStart = timestampStart;
+        this.timestampEnd = timestampEnd;
+        this.kind = kind;
+        this.type = type;
+        this.payload = payload;
+    }
+    clone() {
+        let payload;
+        if (Buffer.isBuffer(this.payload))
+            payload = Buffer.from(this.payload);
+        else
+            payload = String(this.payload);
+        return new SpeechFlowChunk(luxon_1.Duration.fromMillis(this.timestampStart.toMillis()), luxon_1.Duration.fromMillis(this.timestampEnd.toMillis()), this.kind, this.type, payload);
+    }
+}
+exports.SpeechFlowChunk = SpeechFlowChunk;
 /*  the base class for all SpeechFlow nodes  */
 class SpeechFlowNode extends node_events_1.default.EventEmitter {
     id;
+    cfg;
     opts;
     args;
     /*  general constant configuration (for reference)  */
     config = {
-        audioChannels: 1, /* audio mono channel       */
-        audioBitDepth: 16, /* audio PCM 16-bit integer */
-        audioLittleEndian: true, /* audio PCM little-endian  */
-        audioSampleRate: 48000, /* audio 48kHz sample rate  */
-        textEncoding: "utf8" /* UTF-8 text encoding      */
+        audioChannels: 1, /* audio mono channel        */
+        audioBitDepth: 16, /* audio PCM 16-bit integer  */
+        audioLittleEndian: true, /* audio PCM little-endian   */
+        audioSampleRate: 48000, /* audio 48kHz sample rate   */
+        textEncoding: "utf8", /* UTF-8 text encoding       */
+        cacheDir: "" /* directory for cache files */
     };
     /*  announced information  */
     input = "none";
@@ -30,12 +58,28 @@ class SpeechFlowNode extends node_events_1.default.EventEmitter {
     stream = null;
     connectionsIn = new Set();
     connectionsOut = new Set();
+    timeOpen;
+    timeZero = luxon_1.DateTime.fromMillis(0);
+    timeZeroOffset = luxon_1.Duration.fromMillis(0);
     /*  the default constructor  */
-    constructor(id, opts, args) {
+    constructor(id, cfg, opts, args) {
         super();
         this.id = id;
+        this.cfg = cfg;
         this.opts = opts;
         this.args = args;
+        for (const key of Object.keys(cfg)) {
+            const idx = key;
+            if (this.config[idx] !== undefined)
+                this.config[idx] = cfg[key];
+        }
+    }
+    /*  set base/zero time for relative timestamp calculations  */
+    setTimeZero(time) {
+        this.timeZero = time;
+        if (this.timeOpen === undefined)
+            this.timeOpen = this.timeZero;
+        this.timeZeroOffset = this.timeZero.diff(this.timeOpen);
     }
     /*  INTERNAL: utility function: create "params" attribute from constructor of sub-classes  */
     configure(spec) {
@@ -79,6 +123,19 @@ class SpeechFlowNode extends node_events_1.default.EventEmitter {
             else
                 throw new Error(`required parameter "${name}" not given`);
         }
+        for (const name of Object.keys(this.opts)) {
+            if (spec[name] === undefined)
+                throw new Error(`named parameter "${name}" not known`);
+        }
+        for (let i = 0; i < this.args.length; i++) {
+            let found = false;
+            for (const name of Object.keys(spec))
+                if (spec[name].pos === i)
+                    found = true;
+            if (!found)
+                throw new Error(`positional parameter #${i} ("${this.args[i]}") ` +
+                    "not mappable to any known argument");
+        }
     }
     /*  connect node to another one  */
     connect(other) {

package/dst/speechflow-utils.d.ts

@@ -0,0 +1,23 @@
+import Stream from "node:stream";
+import { EventEmitter } from "node:events";
+import { DateTime } from "luxon";
+import { SpeechFlowChunk } from "./speechflow-node";
+export declare function audioBufferDuration(buffer: Buffer, sampleRate?: number, bitDepth?: number, channels?: number, littleEndian?: boolean): number;
+export declare function createTransformStreamForWritableSide(): Stream.Transform;
+export declare function createTransformStreamForReadableSide(type: "text" | "audio", getTimeZero: () => DateTime): Stream.Transform;
+export declare function ensureStreamChunk(type: "audio" | "text", chunk: SpeechFlowChunk | Buffer | string): string | SpeechFlowChunk | Buffer<ArrayBufferLike>;
+export declare function streamChunkEncode(chunk: SpeechFlowChunk): Uint8Array<ArrayBufferLike>;
+export declare function streamChunkDecode(_data: Uint8Array): SpeechFlowChunk;
+export declare class SingleQueue<T> extends EventEmitter {
+    private queue;
+    write(item: T): void;
+    read(): Promise<T>;
+}
+export declare class DoubleQueue<T0, T1> extends EventEmitter {
+    private queue0;
+    private queue1;
+    private notify;
+    write0(item: T0): void;
+    write1(item: T1): void;
+    read(): Promise<[T0, T1]>;
+}