speechflow 1.5.1 → 1.6.1

package/speechflow-cli/src/speechflow-node-t2t-subtitle.ts

@@ -18,7 +18,7 @@ import HAPIWebSocket from "hapi-plugin-websocket"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
+import * as util                           from "./speechflow-util"
 
 type wsPeerCtx = {
     peer: string
@@ -30,9 +30,9 @@ type wsPeerInfo = {
 }
 
 /*  SpeechFlow node for subtitle (text-to-text) "translations"  */
-export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
+export default class SpeechFlowNodeT2TSubtitle extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "subtitle"
+    public static name = "t2t-subtitle"
 
     /*  internal state  */
     private sequenceNo = 1
@@ -44,11 +44,11 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            format: { type: "string", pos: 0, val: "srt", match: /^(?:srt|vtt)$/ },
-            words:  { type: "boolean", val: false },
-            mode:   { type: "string",  val: "export", match: /^(?:export|render)$/ },
-            addr:   { type: "string",  val: "127.0.0.1" },
-            port:   { type: "number",  val: 8585 }
+            format: { type: "string",  pos: 0, val: "srt",    match: /^(?:srt|vtt)$/ },
+            words:  { type: "boolean",         val: false },
+            mode:   { type: "string",          val: "export", match: /^(?:export|render)$/ },
+            addr:   { type: "string",          val: "127.0.0.1" },
+            port:   { type: "number",          val: 8585 }
         })
 
         /*  declare node input/output format  */
@@ -147,7 +147,7 @@ export default class SpeechFlowNodeSubtitle extends SpeechFlowNode {
                                 this.push(chunkNew)
                                 callback()
                             }).catch((error: unknown) => {
-                                callback(utils.ensureError(error))
+                                callback(util.ensureError(error))
                             })
                         }
                     }

package/speechflow-cli/src/speechflow-node-t2t-transformers.ts

@@ -13,16 +13,16 @@ import * as Transformers from "@huggingface/transformers"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
+import * as util                           from "./speechflow-util"
 
 /*  internal utility types  */
 type ConfigEntry = { systemPrompt: string, chat: Array<{ role: string, content: string }> }
 type Config      = { [ key: string ]: ConfigEntry }
 
 /*  SpeechFlow node for Transformers text-to-text translation  */
-export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
+export default class SpeechFlowNodeT2TTransformers extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "transformers"
+    public static name = "t2t-transformers"
 
     /*  internal state  */
     private translator: Transformers.TranslationPipeline    | null = null
@@ -214,7 +214,7 @@ export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
                         this.push(chunk)
                         callback()
                     }).catch((error: unknown) => {
-                        callback(utils.ensureError(error))
+                        callback(util.ensureError(error))
                     })
                 }
             },

package/speechflow-cli/src/speechflow-node-x2x-filter.ts

@@ -9,15 +9,15 @@ import Stream from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
+import * as util                           from "./speechflow-util"
 
 /*  SpeechFlow node for data flow filtering (based on meta information)  */
-export default class SpeechFlowNodeFilter extends SpeechFlowNode {
+export default class SpeechFlowNodeX2XFilter extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "filter"
+    public static name = "x2x-filter"
 
     /*  cached regular expression instance  */
-    private cachedRegExp = new utils.CachedRegExp()
+    private cachedRegExp = new util.CachedRegExp()
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {

package/speechflow-cli/src/speechflow-node-x2x-trace.ts

@@ -14,9 +14,9 @@ import { Duration } from "luxon"
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
 
 /*  SpeechFlow node for data flow tracing  */
-export default class SpeechFlowNodeTrace extends SpeechFlowNode {
+export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "trace"
+    public static name = "x2x-trace"
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {

package/speechflow-cli/src/speechflow-node-xio-device.ts

@@ -12,12 +12,12 @@ import PortAudio        from "@gpeng/naudiodon"
 
 /*  internal dependencies  */
 import SpeechFlowNode   from "./speechflow-node"
-import * as utils       from "./speechflow-utils"
+import * as util        from "./speechflow-util"
 
 /*  SpeechFlow node for device access  */
-export default class SpeechFlowNodeDevice extends SpeechFlowNode {
+export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "device"
+    public static name = "xio-device"
 
     /*  internal state  */
     private io: PortAudio.IoStreamRead
@@ -135,8 +135,8 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
             this.stream = this.io as unknown as Stream.Duplex
 
             /*  convert regular stream into object-mode stream  */
-            const wrapper1 = utils.createTransformStreamForWritableSide()
-            const wrapper2 = utils.createTransformStreamForReadableSide("audio", () => this.timeZero)
+            const wrapper1 = util.createTransformStreamForWritableSide()
+            const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
             this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
         }
         else if (this.params.mode === "r") {
@@ -156,7 +156,7 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
             this.stream = this.io as unknown as Stream.Readable
 
             /*  convert regular stream into object-mode stream  */
-            const wrapper = utils.createTransformStreamForReadableSide("audio", () => this.timeZero)
+            const wrapper = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
             this.stream = Stream.compose(this.stream, wrapper)
         }
         else if (this.params.mode === "w") {
@@ -176,7 +176,7 @@ export default class SpeechFlowNodeDevice extends SpeechFlowNode {
             this.stream = this.io as unknown as Stream.Writable
 
             /*  convert regular stream into object-mode stream  */
-            const wrapper = utils.createTransformStreamForWritableSide()
+            const wrapper = util.createTransformStreamForWritableSide()
             this.stream = Stream.compose(wrapper, this.stream)
         }
         else

package/speechflow-cli/src/speechflow-node-xio-file.ts

@@ -10,12 +10,12 @@ import Stream           from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode   from "./speechflow-node"
-import * as utils       from "./speechflow-utils"
+import * as util        from "./speechflow-util"
 
 /*  SpeechFlow node for file access  */
-export default class SpeechFlowNodeFile extends SpeechFlowNode {
+export default class SpeechFlowNodeXIOFile extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "file"
+    public static name = "xio-file"
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -59,6 +59,27 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
         if (this.params.path === "")
             throw new Error("required parameter \"path\" has to be given")
 
+        /*  utility function: create a writable stream as chunker that
+            writes to process.stdout but properly handles finish events.
+            This ensures the writable side of the composed stream below
+            properly signals completion while keeping process.stdout open
+            (as it's a global stream that shouldn't be closed by individual nodes). */
+        const createStdoutChunker = () =>
+            new Stream.Writable({
+                highWaterMark: this.params.type === "audio" ?
+                    highWaterMarkAudio : highWaterMarkText,
+                write (chunk: Buffer | string, encoding, callback) {
+                    const canContinue = process.stdout.write(chunk, encoding)
+                    if (canContinue)
+                        callback()
+                    else
+                        process.stdout.once("drain", callback)
+                },
+                final (callback) {
+                    callback()
+                }
+            })
+
         /*  dispatch according to mode and path  */
         if (this.params.mode === "rw") {
             if (this.params.path === "-") {
@@ -107,8 +128,8 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
             }
 
             /*  convert regular stream into object-mode stream  */
-            const wrapper1 = utils.createTransformStreamForWritableSide()
-            const wrapper2 = utils.createTransformStreamForReadableSide(
+            const wrapper1 = util.createTransformStreamForWritableSide()
+            const wrapper2 = util.createTransformStreamForReadableSide(
                 this.params.type, () => this.timeZero)
             this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
         }
@@ -124,7 +145,7 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
                     process.stdin.setEncoding(this.config.textEncoding)
                     chunker = new Stream.PassThrough({ highWaterMark: highWaterMarkText })
                 }
-                const wrapper = utils.createTransformStreamForReadableSide(
+                const wrapper = util.createTransformStreamForReadableSide(
                     this.params.type, () => this.timeZero)
                 this.stream = Stream.compose(process.stdin, chunker, wrapper)
             }
@@ -137,7 +158,7 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
                 else
                     readable = fs.createReadStream(this.params.path,
                         { highWaterMark: highWaterMarkText, encoding: this.config.textEncoding })
-                const wrapper = utils.createTransformStreamForReadableSide(
+                const wrapper = util.createTransformStreamForReadableSide(
                     this.params.type, () => this.timeZero)
                 this.stream = Stream.compose(readable, wrapper)
             }
@@ -145,17 +166,13 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
         else if (this.params.mode === "w") {
             if (this.params.path === "-") {
                 /*  standard I/O  */
-                let chunker: Stream.PassThrough
-                if (this.params.type === "audio") {
+                if (this.params.type === "audio")
                     process.stdout.setEncoding()
-                    chunker = new Stream.PassThrough({ highWaterMark: highWaterMarkAudio })
-                }
-                else {
+                else
                     process.stdout.setEncoding(this.config.textEncoding)
-                    chunker = new Stream.PassThrough({ highWaterMark: highWaterMarkText })
-                }
-                const wrapper = utils.createTransformStreamForWritableSide()
-                this.stream = Stream.compose(wrapper, chunker, process.stdout)
+                const chunker = createStdoutChunker()
+                const wrapper = util.createTransformStreamForWritableSide()
+                this.stream = Stream.compose(wrapper, chunker)
             }
             else {
                 /*  file I/O  */
@@ -166,7 +183,7 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
                 else
                     writable = fs.createWriteStream(this.params.path,
                         { highWaterMark: highWaterMarkText, encoding: this.config.textEncoding })
-                const wrapper = utils.createTransformStreamForWritableSide()
+                const wrapper = util.createTransformStreamForWritableSide()
                 this.stream = Stream.compose(wrapper, writable)
             }
         }
@@ -178,18 +195,22 @@ export default class SpeechFlowNodeFile extends SpeechFlowNode {
     async close () {
         /*  shutdown stream  */
         if (this.stream !== null) {
-            await new Promise<void>((resolve, reject) => {
-                if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex) {
-                    this.stream.end((err?: Error) => {
-                        if (err)
-                            reject(err)
-                        else
+            await Promise.race([
+                new Promise<void>((resolve, reject) => {
+                    if (this.stream instanceof Stream.Writable || this.stream instanceof Stream.Duplex) {
+                        if (this.stream.writableEnded || this.stream.destroyed)
                             resolve()
-                    })
-                }
-                else
-                    resolve()
-            })
+                        else
+                            this.stream.end((err?: Error) => {
+                                if (err) reject(err)
+                                else     resolve()
+                            })
+                    }
+                    else
+                        resolve()
+                }),
+                new Promise<void>((resolve) => setTimeout(() => resolve(), 5000))
+            ])
             if (this.params.path !== "-")
                 this.stream.destroy()
             this.stream = null

package/speechflow-cli/src/speechflow-node-xio-mqtt.ts

@@ -13,17 +13,17 @@ import UUID   from "pure-uuid"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
+import * as util                           from "./speechflow-util"
 
 /*  SpeechFlow node for MQTT networking  */
-export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
+export default class SpeechFlowNodeXIOMQTT extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "mqtt"
+    public static name = "xio-mqtt"
 
     /*  internal state  */
     private broker: MQTT.MqttClient | null = null
     private clientId: string = (new UUID(1)).format()
-    private chunkQueue: utils.SingleQueue<SpeechFlowChunk> | null = null
+    private chunkQueue: util.SingleQueue<SpeechFlowChunk> | null = null
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -99,12 +99,12 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
         this.broker.on("disconnect", (packet: MQTT.IDisconnectPacket) => {
             this.log("info", `connection closed to MQTT ${this.params.url}`)
         })
-        this.chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
+        this.chunkQueue = new util.SingleQueue<SpeechFlowChunk>()
         this.broker.on("message", (topic: string, payload: Buffer, packet: MQTT.IPublishPacket) => {
             if (topic !== this.params.topicRead || this.params.mode === "w")
                 return
             try {
-                const chunk = utils.streamChunkDecode(payload)
+                const chunk = util.streamChunkDecode(payload)
                 this.chunkQueue!.write(chunk)
             }
             catch (_err: any) {
@@ -125,7 +125,7 @@ export default class SpeechFlowNodeMQTT extends SpeechFlowNode {
                 else if (!self.broker!.connected)
                     callback(new Error("still no MQTT connection available"))
                 else {
-                    const data = Buffer.from(utils.streamChunkEncode(chunk))
+                    const data = Buffer.from(util.streamChunkEncode(chunk))
                     self.broker!.publish(self.params.topicWrite, data, { qos: 2, retain: false }, (err) => {
                         if (err)
                             callback(new Error(`failed to publish to MQTT topic "${self.params.topicWrite}": ${err}`))

package/speechflow-cli/src/speechflow-node-xio-websocket.ts

@@ -13,12 +13,12 @@ import ReconnWebSocket, { ErrorEvent } from "@opensumi/reconnecting-websocket"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
-import * as utils                          from "./speechflow-utils"
+import * as util                           from "./speechflow-util"
 
 /*  SpeechFlow node for Websocket networking  */
-export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
+export default class SpeechFlowNodeXIOWebSocket extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "websocket"
+    public static name = "xio-websocket"
 
     /*  internal state  */
     private server: ws.WebSocketServer | null = null
@@ -63,7 +63,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             /*  listen locally on a Websocket port  */
             const url = new URL(this.params.listen)
             const websockets = new Set<ws.WebSocket>()
-            const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
+            const chunkQueue = new util.SingleQueue<SpeechFlowChunk>()
             this.server = new ws.WebSocketServer({
                 host: url.hostname,
                 port: Number.parseInt(url.port, 10),
@@ -101,7 +101,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                         buffer = Buffer.from(data)
                     else
                         buffer = Buffer.concat(data)
-                    const chunk = utils.streamChunkDecode(buffer)
+                    const chunk = util.streamChunkDecode(buffer)
                     chunkQueue.write(chunk)
                 })
             })
@@ -122,7 +122,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                     else if (websockets.size === 0)
                         callback(new Error("still no Websocket connections available"))
                     else {
-                        const data = utils.streamChunkEncode(chunk)
+                        const data = util.streamChunkEncode(chunk)
                         const results: Promise<void>[] = []
                         for (const websocket of websockets.values()) {
                             results.push(new Promise<void>((resolve, reject) => {
@@ -172,7 +172,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
             this.client.addEventListener("error", (ev: ErrorEvent) => {
                 this.log("error", `error of connection on URL ${this.params.connect}: ${ev.error.message}`)
             })
-            const chunkQueue = new utils.SingleQueue<SpeechFlowChunk>()
+            const chunkQueue = new util.SingleQueue<SpeechFlowChunk>()
             this.client.addEventListener("message", (ev: MessageEvent) => {
                 if (this.params.mode === "w") {
                     this.log("warning", `connection to URL ${this.params.connect}: ` +
@@ -185,7 +185,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                     return
                 }
                 const buffer = Buffer.from(ev.data)
-                const chunk = utils.streamChunkDecode(buffer)
+                const chunk = util.streamChunkDecode(buffer)
                 chunkQueue.write(chunk)
             })
             this.client.binaryType = "arraybuffer"
@@ -203,7 +203,7 @@ export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
                     else if (!self.client!.OPEN)
                         callback(new Error("still no Websocket connection available"))
                     else {
-                        const data = utils.streamChunkEncode(chunk)
+                        const data = util.streamChunkEncode(chunk)
                         self.client!.send(data)
                         callback()
                     }

package/speechflow-cli/src/{speechflow-utils-audio.ts → speechflow-util-audio.ts}

@@ -10,6 +10,136 @@ import path from "node:path"
 /*  external dependencies  */
 import { AudioContext, AudioWorkletNode } from "node-web-audio-api"
 
+/*  calculate duration of an audio buffer  */
+export function audioBufferDuration (
+    buffer: Buffer,
+    sampleRate   = 48000,
+    bitDepth     = 16,
+    channels     = 1,
+    littleEndian = true
+) {
+    /*  sanity check parameters  */
+    if (!Buffer.isBuffer(buffer))
+        throw new Error("invalid input (Buffer expected)")
+    if (littleEndian !== true)
+        throw new Error("only Little Endian supported")
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (bitDepth <= 0 || bitDepth % 8 !== 0)
+        throw new Error("bit depth must be positive and multiple of 8")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
+
+    /*  calculate duration  */
+    const bytesPerSample = bitDepth / 8
+    const totalSamples = buffer.length / (bytesPerSample * channels)
+    return totalSamples / sampleRate
+}
+
+/*  calculate duration of an audio array  */
+export function audioArrayDuration (
+    arr: Float32Array,
+    sampleRate   = 48000,
+    channels     = 1
+) {
+    /*  sanity check parameters  */
+    if (arr.length === 0)
+        return 0
+    if (sampleRate <= 0)
+        throw new Error("sample rate must be positive")
+    if (channels <= 0)
+        throw new Error("channels must be positive")
+
+    /*  calculate duration  */
+    const totalSamples = arr.length / channels
+    return totalSamples / sampleRate
+}
+
+/*  helper function: convert Buffer in PCM/I16 to Float32Array in PCM/F32 format  */
+export function convertBufToF32 (buf: Buffer, littleEndian = true) {
+    if (buf.length % 2 !== 0)
+        throw new Error("buffer length must be even for 16-bit samples")
+    const dataView = new DataView(buf.buffer)
+    const arr = new Float32Array(buf.length / 2)
+    for (let i = 0; i < arr.length; i++)
+        arr[i] = dataView.getInt16(i * 2, littleEndian) / 32768
+    return arr
+}
+
+/*  helper function: convert Float32Array in PCM/F32 to Buffer in PCM/I16 format  */
+export function convertF32ToBuf (arr: Float32Array) {
+    if (arr.length === 0)
+        return Buffer.alloc(0)
+    const int16Array = new Int16Array(arr.length)
+    for (let i = 0; i < arr.length; i++) {
+        let sample = arr[i]
+        if (Number.isNaN(sample))
+            sample = 0
+        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(sample * 32768)))
+    }
+    return Buffer.from(int16Array.buffer)
+}
+
+/*  helper function: convert Buffer in PCM/I16 to Int16Array  */
+export function convertBufToI16 (buf: Buffer, littleEndian = true) {
+    if (buf.length % 2 !== 0)
+        throw new Error("buffer length must be even for 16-bit samples")
+    const dataView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    const arr = new Int16Array(buf.length / 2)
+    for (let i = 0; i < buf.length / 2; i++)
+        arr[i] = dataView.getInt16(i * 2, littleEndian)
+    return arr
+}
+
+/*  helper function: convert In16Array in PCM/I16 to Buffer  */
+export function convertI16ToBuf (arr: Int16Array, littleEndian = true) {
+    if (arr.length === 0)
+        return Buffer.alloc(0)
+    const buf = Buffer.allocUnsafe(arr.length * 2)
+    for (let i = 0; i < arr.length; i++) {
+        if (littleEndian)
+            buf.writeInt16LE(arr[i], i * 2)
+        else
+            buf.writeInt16BE(arr[i], i * 2)
+    }
+    return buf
+}
+
+/*  process Int16Array in fixed-size segments  */
+export async function processInt16ArrayInSegments (
+    data: Int16Array<ArrayBuffer>,
+    segmentSize: number,
+    processor: (segment: Int16Array<ArrayBuffer>) => Promise<Int16Array<ArrayBuffer>>
+): Promise<Int16Array<ArrayBuffer>> {
+    /*  process full segments  */
+    let i = 0
+    while ((i + segmentSize) <= data.length) {
+        const segment = data.slice(i, i + segmentSize)
+        const result = await processor(segment)
+        data.set(result, i)
+        i += segmentSize
+    }
+
+    /*  process final partial segment if it exists  */
+    if (i < data.length) {
+        const len = data.length - i
+        const segment = new Int16Array(segmentSize)
+        segment.set(data.slice(i), 0)
+        segment.fill(0, len, segmentSize)
+        const result = await processor(segment)
+        data.set(result.slice(0, len), i)
+    }
+    return data
+}
+
+/*  helper functions for linear/decibel conversions  */
+export function lin2dB (x: number): number {
+    return 20 * Math.log10(Math.max(x, 1e-12))
+}
+export function dB2lin (db: number): number {
+    return Math.pow(10, db / 20)
+}
+
 export class WebAudio {
     /*  internal state  */
     public audioContext: AudioContext
@@ -40,7 +170,7 @@ export class WebAudio {
             await this.audioContext.resume()
 
         /*  add audio worklet module  */
-        const url = path.resolve(__dirname, "speechflow-utils-audio-wt.js")
+        const url = path.resolve(__dirname, "speechflow-util-audio-wt.js")
         await this.audioContext.audioWorklet.addModule(url)
 
         /*  create source node  */