speechflow 0.9.0

package/dst/speechflow-node-elevenlabs.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 });
+const node_stream_1 = __importDefault(require("node:stream"));
+const node_events_1 = require("node:events");
+const ElevenLabs = __importStar(require("elevenlabs"));
+const get_stream_1 = require("get-stream");
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*
+const elevenlabsVoices = {
+    "drew":    { name: "Drew",    model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
+    "george":  { name: "George",  model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
+    "bill":    { name: "Bill",    model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
+    "daniel":  { name: "Daniel",  model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
+    "brian":   { name: "Brian",   model: "eleven_turbo_v2",        lang: [ "en"       ] },
+    "sarah":   { name: "Sarah",   model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
+    "racel":   { name: "Racel",   model: "eleven_multilingual_v2", lang: [ "en", "de" ] },
+    "grace":   { name: "Grace",   model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
+    "matilda": { name: "Matilda", model: "eleven_multilingual_v1", lang: [ "en", "de" ] },
+    "alice":   { name: "Alice",   model: "eleven_turbo_v2",        lang: [ "en"       ] }
+}
+*/
+class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
+    elevenlabs = null;
+    constructor(id, opts, args) {
+        super(id, opts, args);
+        this.configure({
+            key: { type: "string", val: process.env.SPEECHFLOW_KEY_ELEVENLABS },
+            voice: { type: "string", val: "Brian", pos: 0 },
+            language: { type: "string", val: "de", pos: 1 }
+        });
+    }
+    async open() {
+        this.input = "text";
+        this.output = "audio";
+        this.elevenlabs = new ElevenLabs.ElevenLabsClient({
+            apiKey: this.params.key
+        });
+        const voices = await this.elevenlabs.voices.getAll();
+        const voice = voices.voices.find((voice) => voice.name === this.params.voice);
+        if (voice === undefined)
+            throw new Error(`invalid ElevenLabs voice "${this.params.voice}"`);
+        const speechStream = (text) => {
+            return this.elevenlabs.textToSpeech.convert(voice.voice_id, {
+                text,
+                optimize_streaming_latency: 2,
+                output_format: "pcm_16000", // S16LE
+                model_id: "eleven_flash_v2_5",
+                /*
+                voice_settings: {
+                    stability: 0,
+                    similarity_boost: 0
+                }
+                */
+            }, {
+                timeoutInSeconds: 30,
+                maxRetries: 10
+            });
+        };
+        const queue = new node_events_1.EventEmitter();
+        this.stream = new node_stream_1.default.Duplex({
+            write(chunk, encoding, callback) {
+                if (encoding !== "utf8" && encoding !== "utf-8")
+                    callback(new Error("only text input supported by Elevenlabs node"));
+                const data = chunk.toString();
+                speechStream(data).then((stream) => {
+                    (0, get_stream_1.getStreamAsBuffer)(stream).then((buffer) => {
+                        queue.emit("audio", buffer);
+                        callback();
+                    }).catch((error) => {
+                        callback(error);
+                    });
+                }).catch((error) => {
+                    callback(error);
+                });
+            },
+            read(size) {
+                queue.once("audio", (buffer) => {
+                    this.push(buffer, "binary");
+                });
+            }
+        });
+    }
+    async close() {
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeElevenlabs;

package/dst/speechflow-node-file.js

@@ -0,0 +1,47 @@
+"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 });
+const node_fs_1 = __importDefault(require("node:fs"));
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+class SpeechFlowNodeDevice extends speechflow_node_1.default {
+    constructor(id, opts, args) {
+        super(id, opts, args);
+        this.configure({
+            path: { type: "string", pos: 0 },
+            mode: { type: "string", pos: 1, val: "r", match: /^(?:r|w|rw)$/ },
+            type: { type: "string", pos: 2, val: "audio", match: /^(?:audio|text)$/ }
+        });
+    }
+    async open() {
+        if (this.params.mode === "r") {
+            this.output = this.params.type;
+            if (this.params.path === "-")
+                this.stream = process.stdin;
+            else
+                this.stream = node_fs_1.default.createReadStream(this.params.path, { encoding: this.params.type === "text" ? this.config.textEncoding : "binary" });
+        }
+        else if (this.params.mode === "w") {
+            this.input = this.params.type;
+            if (this.params.path === "-")
+                this.stream = process.stdout;
+            else
+                this.stream = node_fs_1.default.createWriteStream(this.params.path, { encoding: this.params.type === "text" ? this.config.textEncoding : "binary" });
+        }
+        else
+            throw new Error(`invalid file mode "${this.params.mode}"`);
+    }
+    async close() {
+        if (this.stream !== null && this.params.path !== "-") {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeDevice;

package/dst/speechflow-node-websocket.js

@@ -0,0 +1,147 @@
+"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 });
+const node_stream_1 = __importDefault(require("node:stream"));
+const ws_1 = __importDefault(require("ws"));
+const reconnecting_websocket_1 = __importDefault(require("@opensumi/reconnecting-websocket"));
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
+    server = null;
+    client = null;
+    constructor(id, opts, args) {
+        super(id, opts, args);
+        this.configure({
+            listen: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+))$/ },
+            connect: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/ },
+            type: { type: "string", val: "text", match: /^(?:audio|text)$/ }
+        });
+    }
+    async open() {
+        this.input = this.params.type;
+        this.output = this.params.type;
+        if (this.params.listen !== "") {
+            const url = new URL(this.params.listen);
+            let websocket = null;
+            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) => {
+                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;
+            });
+            server.on("error", (error) => {
+                this.log("error", `error on URL ${this.params.listen}: ${error.message}`);
+                websocket = null;
+            });
+            this.stream = new node_stream_1.default.Duplex({
+                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();
+                        });
+                    }
+                    else
+                        callback(new Error("still no Websocket connection available"));
+                },
+                read(size) {
+                    if (websocket !== null) {
+                        websocket.once("message", (data, isBinary) => {
+                            this.push(data, isBinary ? "binary" : "utf8");
+                        });
+                    }
+                    else
+                        throw new Error("still no Websocket connection available");
+                }
+            });
+        }
+        else if (this.params.connect !== "") {
+            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 on URL ${this.params.connect}`);
+            });
+            this.client.addEventListener("close", (ev) => {
+                this.log("info", `connection closed on URL ${this.params.connect}`);
+            });
+            this.client.addEventListener("error", (ev) => {
+                this.log("error", `error on URL ${this.params.connect}: ${ev.error.message}`);
+            });
+            const client = this.client;
+            client.binaryType = "arraybuffer";
+            this.stream = new node_stream_1.default.Duplex({
+                write(chunk, encoding, callback) {
+                    const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+                    if (client.OPEN) {
+                        client.send(data);
+                        callback();
+                    }
+                    else
+                        callback(new Error("still no Websocket connection available"));
+                },
+                read(size) {
+                    if (client.OPEN) {
+                        client.addEventListener("message", (ev) => {
+                            if (ev.data instanceof ArrayBuffer)
+                                this.push(ev.data, "binary");
+                            else
+                                this.push(ev.data, "utf8");
+                        }, { once: true });
+                    }
+                    else
+                        throw new Error("still no Websocket connection available");
+                }
+            });
+        }
+        else
+            throw new Error("neither listen nor connect mode requested");
+    }
+    async close() {
+        if (this.server !== null) {
+            await new Promise((resolve, reject) => {
+                this.server.close((error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+            this.server = null;
+        }
+        if (this.client !== null) {
+            this.client.close();
+            this.client = null;
+        }
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeWebsocket;

package/dst/speechflow-node.js

@@ -0,0 +1,77 @@
+"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 });
+const node_events_1 = __importDefault(require("node:events"));
+class SpeechFlowNode extends node_events_1.default.EventEmitter {
+    id;
+    opts;
+    args;
+    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      */
+    };
+    input = "none";
+    output = "none";
+    params = {};
+    stream = null;
+    connectionsIn = new Set();
+    connectionsOut = new Set();
+    constructor(id, opts, args) {
+        super();
+        this.id = id;
+        this.opts = opts;
+        this.args = args;
+    }
+    configure(spec) {
+        for (const name of Object.keys(spec)) {
+            if (this.opts[name] !== undefined) {
+                if (typeof this.opts[name] !== spec[name].type)
+                    throw new Error(`invalid type of option "${name}"`);
+                if ("match" in spec[name] && this.opts[name].match(spec[name].match) === null)
+                    throw new Error(`invalid value of option "${name}" (has to match ${spec[name].match})`);
+                this.params[name] = this.opts[name];
+            }
+            else if (this.opts[name] === undefined
+                && "pos" in spec[name]
+                && spec[name].pos < this.args.length) {
+                if (typeof this.args[spec[name].pos] !== spec[name].type)
+                    throw new Error(`invalid type of argument "${name}"`);
+                if ("match" in spec[name] && this.args[spec[name].pos].match(spec[name].match) === null)
+                    throw new Error(`invalid value of option "${name}" (has to match ${spec[name].match})`);
+                this.params[name] = this.args[spec[name].pos];
+            }
+            else if ("val" in spec[name] && spec[name].val !== undefined)
+                this.params[name] = spec[name].val;
+            else
+                throw new Error(`required parameter "${name}" not given`);
+        }
+    }
+    connect(other) {
+        this.connectionsOut.add(other);
+        other.connectionsIn.add(this);
+    }
+    disconnect(other) {
+        if (!this.connectionsOut.has(other))
+            throw new Error("invalid node: not connected to this node");
+        this.connectionsOut.delete(other);
+        other.connectionsIn.delete(this);
+    }
+    log(level, msg, data) {
+        this.emit("log", level, msg, data);
+    }
+    async open() {
+    }
+    async close() {
+    }
+}
+exports.default = SpeechFlowNode;

package/dst/speechflow-util.js

@@ -0,0 +1,37 @@
+"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 });
+const naudiodon_1 = __importDefault(require("@gpeng/naudiodon"));
+class SpeechFlowUtil {
+    static audioDeviceFromURL(mode, url) {
+        const m = url.match(/^(.+?):(.+)$/);
+        if (m === null)
+            throw new Error(`invalid audio device URL "${url}"`);
+        const [, type, name] = m;
+        const apis = naudiodon_1.default.getHostAPIs();
+        const api = apis.HostAPIs.find((api) => api.type.toLowerCase() === type.toLowerCase());
+        if (!api)
+            throw new Error(`invalid audio device type "${type}"`);
+        const devices = naudiodon_1.default.getDevices();
+        console.log(devices);
+        const device = devices.find((device) => {
+            return (((mode === "r" && device.maxInputChannels > 0)
+                || (mode === "w" && device.maxOutputChannels > 0)
+                || (mode === "rw" && device.maxInputChannels > 0 && device.maxOutputChannels > 0)
+                || (mode === "any" && (device.maxInputChannels > 0 || device.maxOutputChannels > 0)))
+                && device.name.match(name)
+                && device.hostAPIName === api.name);
+        });
+        if (!device)
+            throw new Error(`invalid audio device name "${name}" (of audio type "${type}")`);
+        return device;
+    }
+}
+exports.default = SpeechFlowUtil;

package/dst/speechflow.js

@@ -0,0 +1,223 @@
+"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 });
+const cli_io_1 = __importDefault(require("cli-io"));
+const yargs_1 = __importDefault(require("yargs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const flowlink_1 = __importDefault(require("flowlink"));
+const object_path_1 = __importDefault(require("object-path"));
+const speechflow_node_file_1 = __importDefault(require("./speechflow-node-file"));
+const speechflow_node_device_1 = __importDefault(require("./speechflow-node-device"));
+const speechflow_node_websocket_1 = __importDefault(require("./speechflow-node-websocket"));
+const speechflow_node_deepgram_1 = __importDefault(require("./speechflow-node-deepgram"));
+const speechflow_node_deepl_1 = __importDefault(require("./speechflow-node-deepl"));
+const speechflow_node_elevenlabs_1 = __importDefault(require("./speechflow-node-elevenlabs"));
+const package_json_1 = __importDefault(require("../package.json"));
+let cli = null;
+(async () => {
+    /*  parse command-line arguments  */
+    const args = await (0, yargs_1.default)()
+        /* eslint @stylistic/indent: off */
+        .usage("Usage: $0 " +
+        "[-h|--help] " +
+        "[-V|--version] " +
+        "[-v|--verbose <level>] " +
+        "[-e|--expression <expression>] " +
+        "[-f|--expression-file <expression-file>] " +
+        "[-c|--config <key>@<yaml-config-file>] " +
+        "[<argument> [...]]")
+        .help("h").alias("h", "help").default("h", false)
+        .describe("h", "show usage help")
+        .boolean("V").alias("V", "version").default("V", false)
+        .describe("V", "show program version information")
+        .string("v").nargs("v", 1).alias("v", "log-level").default("v", "warning")
+        .describe("v", "level for verbose logging ('none', 'error', 'warning', 'info', 'debug')")
+        .string("e").nargs("e", 1).alias("e", "expression").default("e", "")
+        .describe("e", "FlowLink expression")
+        .string("f").nargs("f", 1).alias("f", "expression-file").default("f", "")
+        .describe("f", "FlowLink expression file")
+        .string("c").nargs("c", 1).alias("c", "config-file").default("c", "")
+        .describe("c", "configuration in format <id>@<file>")
+        .version(false)
+        .strict()
+        .showHelpOnFail(true)
+        .demand(0)
+        .parse(process.argv.slice(2));
+    /*  short-circuit version request  */
+    if (args.version) {
+        process.stderr.write(`${package_json_1.default.name} ${package_json_1.default.version} <${package_json_1.default.homepage}>\n`);
+        process.stderr.write(`${package_json_1.default.description}\n`);
+        process.stderr.write(`Copyright (c) 2024-2025 ${package_json_1.default.author.name} <${package_json_1.default.author.url}>\n`);
+        process.stderr.write(`Licensed under ${package_json_1.default.license} <http://spdx.org/licenses/${package_json_1.default.license}.html>\n`);
+        process.exit(0);
+    }
+    /*  establish CLI environment  */
+    cli = new cli_io_1.default({
+        encoding: "utf8",
+        logLevel: args.logLevel,
+        logTime: true,
+        logPrefix: package_json_1.default.name
+    });
+    /*  handle uncaught exceptions  */
+    process.on("uncaughtException", async (err) => {
+        cli.log("warning", `process crashed with a fatal error: ${err} ${err.stack}`);
+        process.exit(1);
+    });
+    /*  handle unhandled promise rejections  */
+    process.on("unhandledRejection", async (reason, promise) => {
+        if (reason instanceof Error)
+            cli.log("error", `promise rejection not handled: ${reason.message}: ${reason.stack}`);
+        else
+            cli.log("error", `promise rejection not handled: ${reason}`);
+        process.exit(1);
+    });
+    /*  sanity check usage  */
+    let n = 0;
+    if (typeof args.expression === "string" && args.expression !== "")
+        n++;
+    if (typeof args.expressionFile === "string" && args.expressionFile !== "")
+        n++;
+    if (typeof args.configFile === "string" && args.configFile !== "")
+        n++;
+    if (n !== 1)
+        throw new Error("cannot use more than one FlowLink specification source (either option -e, -f or -c)");
+    /*  read configuration  */
+    let config = "";
+    if (typeof args.expression === "string" && args.expression !== "")
+        config = args.expression;
+    else if (typeof args.expressionFile === "string" && args.expressionFile !== "")
+        config = await cli.input(args.expressionFile, { encoding: "utf8" });
+    else if (typeof args.configFile === "string" && args.configFile !== "") {
+        const m = args.configFile.match(/^(.+?)@(.+)$/);
+        if (m === null)
+            throw new Error("invalid configuration file specification (expected \"<key>@<yaml-config-file>\")");
+        const [, key, file] = m;
+        const yaml = await cli.input(file, { encoding: "utf8" });
+        const obj = js_yaml_1.default.load(yaml);
+        if (obj[key] === undefined)
+            throw new Error(`no such key "${key}" found in configuration file`);
+        config = obj[key];
+    }
+    /*  configuration of nodes  */
+    const nodes = {
+        "file": speechflow_node_file_1.default,
+        "device": speechflow_node_device_1.default,
+        "websocket": speechflow_node_websocket_1.default,
+        "deepgram": speechflow_node_deepgram_1.default,
+        "deepl": speechflow_node_deepl_1.default,
+        "elevenlabs": speechflow_node_elevenlabs_1.default
+    };
+    /*  parse configuration into node graph  */
+    const flowlink = new flowlink_1.default({
+        trace: (msg) => {
+            cli.log("debug", msg);
+        }
+    });
+    let nodenum = 1;
+    const variables = { argv: args._, env: process.env };
+    const graphNodes = new Set();
+    flowlink.evaluate(config, {
+        resolveVariable(id) {
+            if (!object_path_1.default.has(variables, id))
+                throw new Error(`failed to resolve variable "${id}"`);
+            const value = object_path_1.default.get(variables, id);
+            cli.log("info", `resolve variable: "${id}" -> "${value}"`);
+            return value;
+        },
+        createNode(id, opts, args) {
+            if (nodes[id] === undefined)
+                throw new Error(`unknown SpeechFlow node "${id}"`);
+            const node = new nodes[id](`${id}[${nodenum++}]`, opts, args);
+            graphNodes.add(node);
+            const params = Object.keys(node.params)
+                .map((key) => `${key}: ${JSON.stringify(node.params[key])}`).join(", ");
+            cli.log("info", `created SpeechFlow node "${node.id}" (${params})`);
+            return node;
+        },
+        connectNode(node1, node2) {
+            cli.log("info", `connect SpeechFlow node "${node1.id}" to node "${node2.id}"`);
+            node1.connect(node2);
+        }
+    });
+    /*  graph processing: PASS 1: activate and sanity check nodes  */
+    for (const node of graphNodes) {
+        /*  connect node events  */
+        node.on("log", (level, msg, data) => {
+            let str = `[${node.id}]: ${msg}`;
+            if (data !== undefined)
+                str += ` (${JSON.stringify(data)})`;
+            cli.log(level, str);
+        });
+        /*  open node  */
+        cli.log("info", `opening node "${node.id}"`);
+        await node.open().catch((err) => {
+            cli.log("error", `[${node.id}]: ${err.message}`);
+            throw new Error(`failed to open node "${node.id}"`);
+        });
+        /*  determine connections  */
+        const connectionsIn = Array.from(node.connectionsIn);
+        const connectionsOut = Array.from(node.connectionsOut);
+        /*  ensure necessary incoming links  */
+        if (node.input !== "none" && connectionsIn.length === 0)
+            throw new Error(`node "${node.id}" requires input but has no input nodes connected`);
+        /*  prune unnecessary incoming links  */
+        if (node.input === "none" && connectionsIn.length > 0)
+            connectionsIn.forEach((other) => { other.disconnect(node); });
+        /*  ensure necessary outgoing links  */
+        if (node.output !== "none" && connectionsOut.length === 0)
+            throw new Error(`node "${node.id}" requires output but has no output nodes connected`);
+        /*  prune unnecessary outgoing links  */
+        if (node.output === "none" && connectionsOut.length > 0)
+            connectionsOut.forEach((other) => { node.disconnect(other); });
+    }
+    /*  graph processing: PASS 2: activate streams  */
+    for (const node of graphNodes) {
+        if (node.stream === null)
+            throw new Error(`stream of outgoing node "${node.id}" still not initialized`);
+        for (const other of Array.from(node.connectionsOut)) {
+            if (other.stream === null)
+                throw new Error(`stream of incoming node "${other.id}" still not initialized`);
+            if (node.output !== other.input)
+                throw new Error(`${node.output} output node "${node.id}" cannot be " +
+                    "connected to ${other.input} input node "${other.id}" (payload is incompatible)`);
+            cli.log("info", `connecting stream of node "${node.id}" to stream of node "${other.id}"`);
+            node.stream.pipe(other.stream);
+        }
+    }
+    /*  gracefully shutdown process  */
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        cli.log("warning", `received signal ${signal} -- shutting down service`);
+        for (const node of graphNodes) {
+            cli.log("info", `closing node "${node.id}"`);
+            const connectionsIn = Array.from(node.connectionsIn);
+            const connectionsOut = Array.from(node.connectionsOut);
+            connectionsIn.forEach((other) => { other.disconnect(node); });
+            connectionsOut.forEach((other) => { node.disconnect(other); });
+            await node.close();
+        }
+        process.exit(1);
+    };
+    process.on("SIGINT", () => {
+        shutdown("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+        shutdown("SIGTERM");
+    });
+})().catch((err) => {
+    if (cli !== null)
+        cli.log("error", err.message);
+    else
+        process.stderr.write(`${package_json_1.default.name}: ERROR: ${err.message}\n`);
+    process.exit(1);
+});