speechflow 0.9.0 → 0.9.1

package/src/speechflow-node-websocket.ts

@@ -4,26 +4,57 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
-import Stream           from "node:stream"
-import ws               from "ws"
-import ReconnWebsocket, { ErrorEvent }  from "@opensumi/reconnecting-websocket"
-import SpeechFlowNode   from "./speechflow-node"
+/*  standard dependencies  */
+import Stream                          from "node:stream"
 
+/*  external dependencies  */
+import ws                              from "ws"
+import ReconnWebsocket, { ErrorEvent } from "@opensumi/reconnecting-websocket"
+
+/*  internal dependencies  */
+import SpeechFlowNode                  from "./speechflow-node"
+
+/*  SpeechFlow node for Websocket networking  */
 export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "websocket"
+
+    /*  internal state  */
     private server: ws.WebSocketServer | null = null
-    private client: WebSocket | null = null
+    private client: WebSocket          | null = null
+
+    /*  construct node  */
     constructor (id: string, opts: { [ id: string ]: any }, args: any[]) {
         super(id, opts, args)
+
+        /*  declare node configuration parameters  */
         this.configure({
             listen:  { type: "string", val: "",     match: /^(?:|ws:\/\/(.+?):(\d+))$/ },
             connect: { type: "string", val: "",     match: /^(?:|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/ },
             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.listen !== "") {
+            this.input  = "none"
+            this.output = this.params.type
+        }
+        else if (this.params.connect !== "") {
+            this.input  = this.params.type
+            this.output = "none"
+        }
     }
+
+    /*  open node  */
     async open () {
-        this.input  = this.params.type
-        this.output = this.params.type
         if (this.params.listen !== "") {
+            /*  listen locally on a Websocket port  */
             const url = new URL(this.params.listen)
             let websocket: ws.WebSocket | null = null
             const server = new ws.WebSocketServer({
@@ -46,8 +77,9 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                 this.log("error", `error on URL ${this.params.listen}: ${error.message}`)
                 websocket = null
             })
+            const textEncoding = this.config.textEncoding
             this.stream = new Stream.Duplex({
-                write (chunk: Buffer, encoding: BufferEncoding, callback: (error?: Error | null | undefined) => void) {
+                write (chunk: Buffer, encoding, callback) {
                     const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength)
                     if (websocket !== null) {
                         websocket.send(data, (error) => {
@@ -61,7 +93,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                 read (size: number) {
                     if (websocket !== null) {
                         websocket.once("message", (data, isBinary) => {
-                            this.push(data, isBinary ? "binary" : "utf8")
+                            this.push(data, isBinary ? "binary" : textEncoding)
                         })
                     }
                     else
@@ -70,6 +102,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             })
         }
         else if (this.params.connect !== "") {
+            /*  connect remotely to a Websocket port  */
             this.client = new ReconnWebsocket(this.params.connect, [], {
                 WebSocket:                   ws,
                 WebSocketOptions:            {},
@@ -90,8 +123,9 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             })
             const client = this.client
             client.binaryType = "arraybuffer"
+            const textEncoding = this.config.textEncoding
             this.stream = new Stream.Duplex({
-                write (chunk: Buffer, encoding: BufferEncoding, callback: (error?: Error | null | undefined) => void) {
+                write (chunk: Buffer, encoding, callback) {
                     const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength)
                     if (client.OPEN) {
                         client.send(data)
@@ -106,7 +140,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                             if (ev.data instanceof ArrayBuffer)
                                 this.push(ev.data, "binary")
                             else
-                                this.push(ev.data, "utf8")
+                                this.push(ev.data, textEncoding)
                         }, { once: true })
                     }
                     else
@@ -114,10 +148,11 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                 }
             })
         }
-        else
-            throw new Error("neither listen nor connect mode requested")
     }
+
+    /*  close node  */
     async close () {
+        /*  close Websocket server  */
         if (this.server !== null) {
             await new Promise<void>((resolve, reject) => {
                 this.server!.close((error) => {
@@ -127,10 +162,14 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             })
             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

package/src/speechflow-node.ts

@@ -4,73 +4,95 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
-import Events  from "node:events"
-import Stream  from "node:stream"
+/*  standard dependencies  */
+import Events from "node:events"
+import Stream from "node:stream"
 
+/*  the base class for all SpeechFlow nodes  */
 export default class SpeechFlowNode extends Events.EventEmitter {
-    public config = {
+    /*  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      */
     } as const
-    public input  = "none"
-    public output = "none"
-    public params = {} as { [ id: string ]: any }
-    public stream: Stream.Writable | Stream.Readable | Stream.Duplex | null = null
 
-    public connectionsIn  = new Set<SpeechFlowNode>()
-    public connectionsOut = new Set<SpeechFlowNode>()
+    /*  announced information  */
+    input  = "none"
+    output = "none"
+    params: { [ id: string ]: any } = {}
+    stream: Stream.Writable | Stream.Readable | Stream.Duplex | null = null
+    connectionsIn  = new Set<SpeechFlowNode>()
+    connectionsOut = new Set<SpeechFlowNode>()
 
+    /*  the default constructor  */
     constructor (
-        public id: string,
+        public  id:   string,
         private opts: { [ id: string ]: any },
         private args: any[]
     ) {
         super()
     }
 
+    /*  INTERNAL: utility function: create "params" attribute from constructor of sub-classes  */
     configure (spec: { [ id: string ]: { type: string, pos?: number, val?: any, match?: RegExp } }) {
         for (const name of Object.keys(spec)) {
             if (this.opts[name] !== undefined) {
+                /*  named parameter  */
                 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})`)
+                    throw new Error(`invalid type of named parameter "${name}" ` +
+                        `(has to be ${spec[name].type})`)
+                if ("match" in spec[name]
+                    && this.opts[name].match(spec[name].match) === null)
+                    throw new Error(`invalid value of named parameter "${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) {
+                && typeof spec[name].pos === "number"
+                && spec[name].pos < this.args.length) {
+                /*  positional argument  */
                 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})`)
+                    throw new Error(`invalid type of positional parameter "${name}" ` +
+                        `(has to be ${spec[name].type})`)
+                if ("match" in spec[name]
+                    && this.args[spec[name].pos!].match(spec[name].match) === null)
+                    throw new Error(`invalid value of positional parameter "${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)
+                /*  default argument  */
                 this.params[name] = spec[name].val
             else
                 throw new Error(`required parameter "${name}" not given`)
         }
     }
+
+    /*  connect node to another one  */
     connect (other: SpeechFlowNode) {
         this.connectionsOut.add(other)
         other.connectionsIn.add(this)
     }
+
+    /*  disconnect node from another one  */
     disconnect (other: SpeechFlowNode) {
         if (!this.connectionsOut.has(other))
             throw new Error("invalid node: not connected to this node")
         this.connectionsOut.delete(other)
         other.connectionsIn.delete(this)
     }
+
+    /*  internal log function  */
     log (level: string, msg: string, data?: any) {
         this.emit("log", level, msg, data)
     }
-    async open () {
-    }
-    async close () {
-    }
+
+    /*  default implementation for open/close operations  */
+    async open  () {}
+    async close () {}
 }
 

package/src/speechflow.ts

@@ -4,25 +4,26 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
+/*  standard dependencies  */
 import Stream                   from "node:stream"
 
+/*  external dependencies  */
 import CLIio                    from "cli-io"
 import yargs                    from "yargs"
 import jsYAML                   from "js-yaml"
 import FlowLink                 from "flowlink"
 import objectPath               from "object-path"
+import installedPackages        from "installed-packages"
+import dotenvx                  from "@dotenvx/dotenvx"
 
+/*  internal dependencies  */
 import SpeechFlowNode           from "./speechflow-node"
-import SpeechFlowNodeFile       from "./speechflow-node-file"
-import SpeechFlowNodeDevice     from "./speechflow-node-device"
-import SpeechFlowNodeWebsocket  from "./speechflow-node-websocket"
-import SpeechFlowNodeDeepgram   from "./speechflow-node-deepgram"
-import SpeechFlowNodeDeepL      from "./speechflow-node-deepl"
-import SpeechFlowNodeElevenLabs from "./speechflow-node-elevenlabs"
-
 import pkg                      from "../package.json"
 
+/*  central CLI context  */
 let cli: CLIio | null = null
+
+/*  establish asynchronous environment  */
 ;(async () => {
     /*  parse command-line arguments  */
     const args = await yargs()
@@ -57,7 +58,7 @@ let cli: CLIio | null = null
 
     /*  short-circuit version request  */
     if (args.version) {
-        process.stderr.write(`${pkg.name} ${pkg.version} <${pkg.homepage}>\n`)
+        process.stderr.write(`SpeechFlow ${pkg["x-stdver"]} (${pkg["x-release"]}) <${pkg.homepage}>\n`)
         process.stderr.write(`${pkg.description}\n`)
         process.stderr.write(`Copyright (c) 2024-2025 ${pkg.author.name} <${pkg.author.url}>\n`)
         process.stderr.write(`Licensed under ${pkg.license} <http://spdx.org/licenses/${pkg.license}.html>\n`)
@@ -72,6 +73,15 @@ let cli: CLIio | null = null
         logPrefix: pkg.name
     })
 
+    /*  provide startup information  */
+    cli.log("info", `starting SpeechFlow ${pkg["x-stdver"]} (${pkg["x-release"]})`)
+
+    /*  load .env files  */
+    const result = dotenvx.config({ encoding: "utf8", quiet: true })
+    if (result?.parsed !== undefined)
+        for (const key of Object.keys(result.parsed))
+            cli.log("info", `loaded environment variable "${key}" from ".env" files`)
+
     /*  handle uncaught exceptions  */
     process.on("uncaughtException", async (err: Error) => {
         cli!.log("warning", `process crashed with a fatal error: ${err} ${err.stack}`)
@@ -113,17 +123,50 @@ let cli: CLIio | null = null
         config = obj[key] as string
     }
 
-    /*  configuration of nodes  */
-    const nodes: { [ id: string ]: typeof SpeechFlowNode } = {
-        "file":       SpeechFlowNodeFile,
-        "device":     SpeechFlowNodeDevice,
-        "websocket":  SpeechFlowNodeWebsocket,
-        "deepgram":   SpeechFlowNodeDeepgram,
-        "deepl":      SpeechFlowNodeDeepL,
-        "elevenlabs": SpeechFlowNodeElevenLabs
+    /*  track the available SpeechFlow nodes  */
+    const nodes: { [ id: string ]: typeof SpeechFlowNode } = {}
+
+    /*  load internal SpeechFlow nodes  */
+    const pkgsI = [
+        "./speechflow-node-file.js",
+        "./speechflow-node-device.js",
+        "./speechflow-node-websocket.js",
+        "./speechflow-node-ffmpeg.js",
+        "./speechflow-node-deepgram.js",
+        "./speechflow-node-deepl.js",
+        "./speechflow-node-elevenlabs.js",
+        "./speechflow-node-gemma.js",
+    ]
+    for (const pkg of pkgsI) {
+        let node: any = await import(pkg)
+        while (node.default !== undefined)
+            node = node.default
+        if (typeof node === "function" && typeof node.name === "string") {
+            cli.log("info", `loading SpeechFlow node "${node.name}" from internal module`)
+            nodes[node.name] = node as typeof SpeechFlowNode
+        }
+    }
+
+    /*  load external SpeechFlow nodes  */
+    const pkgsE = await installedPackages()
+    for (const pkg of pkgsE) {
+        if (pkg.match(/^(?:@[^/]+\/)?speechflow-node-.+$/)) {
+            let node: any = await import(pkg)
+            while (node.default !== undefined)
+                node = node.default
+            if (typeof node === "function" && typeof node.name === "string") {
+                if (nodes[node.name] !== undefined) {
+                    cli.log("warning", `failed loading SpeechFlow node "${node.name}" ` +
+                        `from external module "${pkg}" -- node already exists`)
+                    continue
+                }
+                cli.log("info", `loading SpeechFlow node "${node.name}" from external module "${pkg}"`)
+                nodes[node.name] = node as typeof SpeechFlowNode
+            }
+        }
     }
 
-    /*  parse configuration into node graph  */
+    /*  graph processing: PASS 1: parse DSL and create and connect nodes  */
     const flowlink = new FlowLink<SpeechFlowNode>({
         trace: (msg: string) => {
             cli!.log("debug", msg)
@@ -142,37 +185,22 @@ let cli: CLIio | null = null
         },
         createNode (id: string, opts: { [ id: string ]: any }, args: any[]) {
             if (nodes[id] === undefined)
-                throw new Error(`unknown SpeechFlow node "${id}"`)
+                throw new Error(`unknown 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})`)
+            cli!.log("info", `create node "${node.id}" (${params})`)
+            graphNodes.add(node)
             return node
         },
         connectNode (node1: SpeechFlowNode, node2: SpeechFlowNode) {
-            cli!.log("info", `connect SpeechFlow node "${node1.id}" to node "${node2.id}"`)
+            cli!.log("info", `connect node "${node1.id}" to node "${node2.id}"`)
             node1.connect(node2)
         }
     })
 
-    /*  graph processing: PASS 1: activate and sanity check nodes  */
+    /*  graph processing: PASS 2: prune connections of nodes  */
     for (const node of graphNodes) {
-        /*  connect node events  */
-        node.on("log", (level: string, msg: string, data?: any) => {
-            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: Error) => {
-            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)
@@ -192,20 +220,47 @@ let cli: CLIio | null = null
         /*  prune unnecessary outgoing links  */
         if (node.output === "none" && connectionsOut.length > 0)
             connectionsOut.forEach((other) => { node.disconnect(other) })
+
+        /*  check for payload compatibility  */
+        for (const other of connectionsOut)
+            if (other.input !== node.output)
+                throw new Error(`${node.output} output node "${node.id}" cannot be ` +
+                    `connected to ${other.input} input node "${other.id}" (payload is incompatible)`)
     }
 
-    /*  graph processing: PASS 2: activate streams  */
+    /*  graph processing: PASS 3: open nodes  */
+    for (const node of graphNodes) {
+        /*  connect node events  */
+        node.on("log", (level: string, msg: string, data?: any) => {
+            let str = `[${node.id}]: ${msg}`
+            if (data !== undefined)
+                str += ` (${JSON.stringify(data)})`
+            cli!.log(level, str)
+        })
+
+        /*  open node  */
+        cli!.log("info", `open node "${node.id}"`)
+        await node.open().catch((err: Error) => {
+            cli!.log("error", `[${node.id}]: ${err.message}`)
+            throw new Error(`failed to open node "${node.id}"`)
+        })
+    }
+
+    /*  graph processing: PASS 4: connect node streams  */
     for (const node of graphNodes) {
         if (node.stream === null)
-            throw new Error(`stream of outgoing node "${node.id}" still not initialized`)
+            throw new Error(`stream of 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 as Stream.Writable)
+            cli!.log("info", `connect stream of node "${node.id}" to stream of node "${other.id}"`)
+            if (!( node.stream instanceof Stream.Readable
+                || node.stream instanceof Stream.Duplex  ))
+                throw new Error(`stream of output node "${node.id}" is neither of Readable nor Duplex type`)
+            if (!( other.stream instanceof Stream.Writable
+                || other.stream instanceof Stream.Duplex  ))
+                throw new Error(`stream of input node "${other.id}" is neither of Writable nor Duplex type`)
+            node.stream.pipe(other.stream)
         }
     }
 
@@ -216,14 +271,55 @@ let cli: CLIio | null = null
             return
         shuttingDown = true
         cli!.log("warning", `received signal ${signal} -- shutting down service`)
+
+        /*  graph processing: PASS 1: disconnect node streams  */
+        for (const node of graphNodes) {
+            if (node.stream === null) {
+                cli!.log("warning", `stream of node "${node.id}" no longer initialized`)
+                continue
+            }
+            for (const other of Array.from(node.connectionsOut)) {
+                if (other.stream === null) {
+                    cli!.log("warning", `stream of incoming node "${other.id}" no longer initialized`)
+                    continue
+                }
+                if (!( node.stream instanceof Stream.Readable
+                    || node.stream instanceof Stream.Duplex  )) {
+                    cli!.log("warning", `stream of output node "${node.id}" is neither of Readable nor Duplex type`)
+                    continue
+                }
+                if (!( other.stream instanceof Stream.Writable
+                    || other.stream instanceof Stream.Duplex  )) {
+                    cli!.log("warning", `stream of input node "${other.id}" is neither of Writable nor Duplex type`)
+                    continue
+                }
+                cli!.log("info", `disconnect stream of node "${node.id}" from stream of node "${other.id}"`)
+                node.stream.unpipe(other.stream)
+            }
+        }
+
+        /*  graph processing: PASS 2: close nodes  */
         for (const node of graphNodes) {
-            cli!.log("info", `closing node "${node.id}"`)
+            cli!.log("info", `close node "${node.id}"`)
+            await node.close()
+        }
+
+        /*  graph processing: PASS 3: disconnect nodes  */
+        for (const node of graphNodes) {
+            cli!.log("info", `disconnect 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()
         }
+
+        /*  graph processing: PASS 4: shutdown nodes  */
+        for (const node of graphNodes) {
+            cli!.log("info", `destroy node "${node.id}"`)
+            graphNodes.delete(node)
+        }
+
+        /*  terminate process  */
         process.exit(1)
     }
     process.on("SIGINT", () => {

package/dst/speechflow-util.js

@@ -1,37 +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 });
-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/src/speechflow-util.ts

@@ -1,36 +0,0 @@
-/*
-**  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>
-*/
-
-import PortAudio from "@gpeng/naudiodon"
-
-export default class SpeechFlowUtil {
-    static audioDeviceFromURL (mode: "any" | "r" | "w" | "rw", url: string) {
-        const m = url.match(/^(.+?):(.+)$/)
-        if (m === null)
-            throw new Error(`invalid audio device URL "${url}"`)
-        const [ , type, name ] = m
-        const apis = PortAudio.getHostAPIs()
-        const api = apis.HostAPIs.find((api) => api.type.toLowerCase() === type.toLowerCase())
-        if (!api)
-            throw new Error(`invalid audio device type "${type}"`)
-        const devices = PortAudio.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
-    }
-}
-