@grame/faustwasm 0.9.6 → 0.10.0

package/assets/standalone/create-node.js

@@ -172,6 +172,81 @@ async function requestPermissions() {
     }
 }
 
+/**
+ * Key2Midi: maps keyboard input to MIDI messages.
+ */
+class Key2Midi {
+    static KEY_MAP = {
+        a: 0, w: 1, s: 2, e: 3, d: 4, f: 5, t: 6, g: 7,
+        y: 8, h: 9, u: 10, j: 11, k: 12, o: 13, l: 14, p: 15, ";": 16,
+        z: "PREV", x: "NEXT", c: "VELDOWN", v: "VELUP"
+    };
+
+    constructor({ keyMap = Key2Midi.KEY_MAP, offset = 60, velocity = 100, handler = console.log } = {}) {
+        this.keyMap = keyMap;
+        this.offset = offset;
+        this.velocity = velocity;
+        this.velMap = [20, 40, 60, 80, 100, 127];
+        this.handler = handler;
+        this.pressed = {};
+
+        this.onKeyDown = this.onKeyDown.bind(this);
+        this.onKeyUp = this.onKeyUp.bind(this);
+    }
+
+    start() {
+        window.addEventListener("keydown", this.onKeyDown);
+        window.addEventListener("keyup", this.onKeyUp);
+    }
+
+    stop() {
+        window.removeEventListener("keydown", this.onKeyDown);
+        window.removeEventListener("keyup", this.onKeyUp);
+    }
+
+    onKeyDown(e) {
+        const key = e.key.toLowerCase();
+        if (this.pressed[key]) return;
+        this.pressed[key] = true;
+
+        const val = this.keyMap[key];
+        if (typeof val === "number") {
+            const note = val + this.offset;
+            this.handler([0x90, note, this.velocity]);
+        } else if (val === "PREV") {
+            this.offset -= 1;
+        } else if (val === "NEXT") {
+            this.offset += 1;
+        } else if (val === "VELDOWN") {
+            const idx = Math.max(0, this.velMap.indexOf(this.velocity) - 1);
+            this.velocity = this.velMap[idx];
+        } else if (val === "VELUP") {
+            const idx = Math.min(this.velMap.length - 1, this.velMap.indexOf(this.velocity) + 1);
+            this.velocity = this.velMap[idx];
+        }
+    }
+
+    onKeyUp(e) {
+        const key = e.key.toLowerCase();
+        const val = this.keyMap[key];
+        if (typeof val === "number") {
+            const note = val + this.offset;
+            this.handler([0x80, note, this.velocity]);
+        }
+        delete this.pressed[key];
+    }
+}
+
+/**
+ * Creates a Key2Midi instance.
+ * 
+ * @param {function} handler - The function to handle MIDI messages.
+ * @returns {Key2Midi} - The Key2Midi instance.
+ */
+function createKey2MIDI(handler) {
+    return new Key2Midi({ handler: handler });
+}
+
 // Export the functions
-export { createFaustNode, createFaustUI, connectToAudioInput, requestPermissions };
+export { createFaustNode, createFaustUI, createKey2MIDI, connectToAudioInput, requestPermissions };
 

package/assets/standalone/index copie.js

@@ -0,0 +1,171 @@
+// Set to > 0 if the DSP is polyphonic
+const FAUST_DSP_VOICES = 0;
+
+/**
+ * @typedef {import("./faustwasm").FaustAudioWorkletNode} FaustAudioWorkletNode
+ * @typedef {import("./faustwasm").FaustDspMeta} FaustDspMeta
+ * @typedef {import("./faustwasm").FaustUIDescriptor} FaustUIDescriptor
+ * @typedef {import("./faustwasm").FaustUIGroup} FaustUIGroup
+ * @typedef {import("./faustwasm").FaustUIItem} FaustUIItem
+ */
+
+/**
+ * Registers the service worker.
+ */
+if ("serviceWorker" in navigator) {
+    window.addEventListener("load", () => {
+        navigator.serviceWorker.register("./service-worker.js")
+            .then(reg => console.log("Service Worker registered", reg))
+            .catch(err => console.log("Service Worker registration failed", err));
+    });
+}
+
+/** @type {HTMLSpanElement} */
+const $spanAudioInput = document.getElementById("audio-input");
+/** @type {HTMLSpanElement} */
+const $spanMidiInput = document.getElementById("midi-input");
+/** @type {HTMLSelectElement} */
+const $selectAudioInput = document.getElementById("select-audio-input");
+/** @type {HTMLSelectElement} */
+const $selectMidiInput = document.getElementById("select-midi-input");
+/** @type {HTMLSelectElement} */
+const $buttonDsp = document.getElementById("button-dsp");
+/** @type {HTMLDivElement} */
+const $divFaustUI = document.getElementById("div-faust-ui");
+
+/** @type {typeof AudioContext} */
+const AudioCtx = window.AudioContext || window.webkitAudioContext;
+const audioContext = new AudioCtx({ latencyHint: 0.00001 });
+audioContext.destination.channelInterpretation = "discrete";
+audioContext.suspend();
+
+$buttonDsp.disabled = true;
+
+// Declare faustNode as a global variable
+let faustNode;
+
+// Called at load time
+(async () => {
+
+    const { createFaustNode, createKey2MIDI, connectToAudioInput, createFaustUI } = await import("./create-node.js");
+
+    /**
+    * @param {FaustAudioWorkletNode} faustNode 
+    */
+    const buildAudioDeviceMenu = async (faustNode) => {
+
+        let inputStreamNode = null;
+        const handleDeviceChange = async () => {
+            const devicesInfo = await navigator.mediaDevices.enumerateDevices();
+            $selectAudioInput.innerHTML = "";
+            devicesInfo.forEach((deviceInfo, i) => {
+                const { kind, deviceId, label } = deviceInfo;
+                if (kind === "audioinput") {
+                    const option = new Option(label || `microphone ${i + 1}`, deviceId);
+                    $selectAudioInput.add(option);
+                }
+            });
+        }
+        await handleDeviceChange();
+        navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange)
+        $selectAudioInput.onchange = async () => {
+            const id = $selectAudioInput.value;
+            if (faustNode.getNumInputs() > 0) {
+                inputStreamNode = await connectToAudioInput(audioContext, id, faustNode, inputStreamNode);
+            }
+        };
+
+        // Connect to the default audio input device
+        if (faustNode.getNumInputs() > 0) {
+            inputStreamNode = await connectToAudioInput(audioContext, null, faustNode, inputStreamNode);
+        }
+    };
+
+    /**
+     * @param {FaustAudioWorkletNode} faustNode 
+     */
+    const buildMidiDeviceMenu = async (faustNode) => {
+
+        // Keyboard to MIDI handing
+        let keyboard2MIDI = createKey2MIDI((event) => faustNode.midiMessage(event));
+        keyboard2MIDI.start();
+
+        const midiAccess = await navigator.requestMIDIAccess();
+        /** @type {WebMidi.MIDIInput} */
+        let currentInput;
+        /**
+         * @param {WebMidi.MIDIMessageEvent} e
+         */
+        const handleMidiMessage = e => faustNode.midiMessage(e.data);
+        const handleStateChange = () => {
+            const { inputs } = midiAccess;
+            if ($selectMidiInput.options.length === inputs.size + 1) return;
+            if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
+            $selectMidiInput.innerHTML = '<option value="-1" disabled selected>Select...</option>';
+            inputs.forEach((midiInput) => {
+                const { name, id } = midiInput;
+                const option = new Option(name, id);
+                $selectMidiInput.add(option);
+            });
+        };
+        handleStateChange();
+        midiAccess.addEventListener("statechange", handleStateChange);
+        $selectMidiInput.onchange = () => {
+            if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
+            const id = $selectMidiInput.value;
+            currentInput = midiAccess.inputs.get(id);
+            currentInput.addEventListener("midimessage", handleMidiMessage);
+        };
+    };
+
+    // To test the ScriptProcessorNode mode
+    // const { faustNode, dspMeta: { name } } = await createFaustNode(audioContext, "FAUST_DSP_NAME", FAUST_DSP_VOICES, true);
+    const result = await createFaustNode(audioContext, "FAUST_DSP_NAME", FAUST_DSP_VOICES);
+    faustNode = result.faustNode;  // Assign to the global variable
+    if (!faustNode) throw new Error("Faust DSP not compiled");
+
+    // Create the Faust UI
+    await createFaustUI($divFaustUI, faustNode);
+
+    // Connect the Faust node to the audio output
+    faustNode.connect(audioContext.destination);
+
+    // Build the audio device menu
+    if (faustNode.numberOfInputs > 0) await buildAudioDeviceMenu(faustNode);
+    else $spanAudioInput.hidden = true;
+
+    // Build the MIDI device menu
+    if (navigator.requestMIDIAccess) await buildMidiDeviceMenu(faustNode);
+    else $spanMidiInput.hidden = true;
+
+})();
+
+// Set the title and enable the DSP button
+$buttonDsp.disabled = false;
+document.title = name;
+let sensorHandlersBound = false;
+
+// Activate AudioContext and Sensors on user interaction
+$buttonDsp.onclick = async () => {
+
+    // Import the requestPermissions function
+    const { requestPermissions } = await import("./create-node.js");
+
+    // Request permission for sensors
+    await requestPermissions();
+
+    // Activate sensor listeners
+    if (!sensorHandlersBound) {
+        await faustNode.startSensors();
+        sensorHandlersBound = true;
+    }
+
+    // Activate or suspend the AudioContext
+    if (audioContext.state === "running") {
+        $buttonDsp.textContent = "Suspended";
+        await audioContext.suspend();
+    } else if (audioContext.state === "suspended") {
+        $buttonDsp.textContent = "Running";
+        await audioContext.resume();
+    }
+}

package/assets/standalone/index-pwa.js

@@ -101,6 +101,22 @@ function stopMIDI() {
 let sensorHandlersBound = false;
 let midiHandlersBound = false;
 
+// Keyboard to MIDI handing
+let keyboard2MIDI = null;
+
+async function startKeyboard2MIDI() {
+    // Import the create-node module
+    const { createKey2MIDI } = await import("./create-node.js");
+
+    keyboard2MIDI = createKey2MIDI((event) => faustNode.midiMessage(event));
+    keyboard2MIDI.start();
+}
+
+function stopKeyboard2MIDI() {
+    keyboard2MIDI.stop();
+    keyboard2MIDI = null;
+}
+
 // Function to activate MIDI and Sensors on user interaction
 async function activateMIDISensors() {
 
@@ -119,6 +135,7 @@ async function activateMIDISensors() {
     // Initialize the MIDI setup
     if (!midiHandlersBound) {
         startMIDI();
+        await startKeyboard2MIDI();
         midiHandlersBound = true;
     }
 
@@ -153,6 +170,7 @@ async function deactivateAudioMIDISensors() {
     // Deactivate the MIDI setup
     if (midiHandlersBound && FAUST_DSP_VOICES > 0) {
         stopMIDI();
+        stopKeyboard2MIDI();
         midiHandlersBound = false;
     }
 }

package/assets/standalone/index.js

@@ -47,7 +47,7 @@ let faustNode;
 // Called at load time
 (async () => {
 
-    const { createFaustNode, connectToAudioInput, createFaustUI } = await import("./create-node.js");
+    const { createFaustNode, createKey2MIDI, connectToAudioInput, createFaustUI } = await import("./create-node.js");
 
     /**
     * @param {FaustAudioWorkletNode} faustNode 
@@ -85,6 +85,11 @@ let faustNode;
      * @param {FaustAudioWorkletNode} faustNode 
      */
     const buildMidiDeviceMenu = async (faustNode) => {
+
+        // Keyboard to MIDI handling - create but don't start yet
+        let keyboard2MIDI = createKey2MIDI((event) => faustNode.midiMessage(event));
+        let isKeyboardActive = false;
+
         const midiAccess = await navigator.requestMIDIAccess();
         /** @type {WebMidi.MIDIInput} */
         let currentInput;
@@ -94,9 +99,18 @@ let faustNode;
         const handleMidiMessage = e => faustNode.midiMessage(e.data);
         const handleStateChange = () => {
             const { inputs } = midiAccess;
-            if ($selectMidiInput.options.length === inputs.size + 1) return;
+            // Check if we need to rebuild the menu
+            const expectedOptions = inputs.size + 2; // +1 for "Select..." and +1 for "Keyboard"
+            if ($selectMidiInput.options.length === expectedOptions) return;
+
             if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
             $selectMidiInput.innerHTML = '<option value="-1" disabled selected>Select...</option>';
+
+            // Add computer keyboard option
+            const keyboardOption = new Option("Computer Keyboard", "Computer Keyboard");
+            $selectMidiInput.add(keyboardOption);
+
+            // Add MIDI device options
             inputs.forEach((midiInput) => {
                 const { name, id } = midiInput;
                 const option = new Option(name, id);
@@ -106,10 +120,29 @@ let faustNode;
         handleStateChange();
         midiAccess.addEventListener("statechange", handleStateChange);
         $selectMidiInput.onchange = () => {
+            // Disconnect previous MIDI input
             if (currentInput) currentInput.removeEventListener("midimessage", handleMidiMessage);
-            const id = $selectMidiInput.value;
-            currentInput = midiAccess.inputs.get(id);
-            currentInput.addEventListener("midimessage", handleMidiMessage);
+            currentInput = null;
+
+            // Stop Computer Keyboard if it was active
+            if (isKeyboardActive) {
+                keyboard2MIDI.stop();
+                isKeyboardActive = false;
+            }
+
+            const selectedValue = $selectMidiInput.value;
+
+            if (selectedValue === "Computer Keyboard") {
+                // Activate keyboard MIDI
+                keyboard2MIDI.start();
+                isKeyboardActive = true;
+            } else {
+                // Activate selected MIDI device
+                currentInput = midiAccess.inputs.get(selectedValue);
+                if (currentInput) {
+                    currentInput.addEventListener("midimessage", handleMidiMessage);
+                }
+            }
         };
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grame/faustwasm",
-  "version": "0.9.6",
+  "version": "0.10.0",
   "description": "WebAssembly version of Faust Compiler",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",

package/test/organ/create-node.js

@@ -0,0 +1,252 @@
+// @ts-check
+
+/**
+ * @typedef {{ dspModule: WebAssembly.Module; dspMeta: FaustDspMeta; effectModule?: WebAssembly.Module; effectMeta?: FaustDspMeta; mixerModule?: WebAssembly.Module }} FaustDspDistribution
+ * @typedef {import("./faustwasm").FaustDspMeta} FaustDspMeta
+ * @typedef {import("./faustwasm").FaustMonoAudioWorkletNode} FaustMonoAudioWorkletNode
+ * @typedef {import("./faustwasm").FaustPolyAudioWorkletNode} FaustPolyAudioWorkletNode
+ * @typedef {import("./faustwasm").FaustMonoScriptProcessorNode} FaustMonoScriptProcessorNode
+ * @typedef {import("./faustwasm").FaustPolyScriptProcessorNode} FaustPolyScriptProcessorNode
+ * @typedef {FaustMonoAudioWorkletNode | FaustPolyAudioWorkletNode | FaustMonoScriptProcessorNode | FaustPolyScriptProcessorNode} FaustNode
+ */
+
+/**
+ * Creates a Faust audio node for use in the Web Audio API.
+ *
+ * @param {AudioContext} audioContext - The Web Audio API AudioContext to which the Faust audio node will be connected.
+ * @param {string} [dspName] - The name of the DSP to be loaded.
+ * @param {number} [voices] - The number of voices to be used for polyphonic DSPs.
+ * @param {boolean} [sp] - Whether to create a ScriptProcessorNode instead of an AudioWorkletNode.
+ * @returns {Promise<{ faustNode: FaustNode | null; dspMeta: FaustDspMeta }>} - An object containing the Faust audio node and the DSP metadata.
+ */
+const createFaustNode = async (audioContext, dspName = "template", voices = 0, sp = false, bufferSize = 512) => {
+    // Set to true if the DSP has an effect
+    const FAUST_DSP_HAS_EFFECT = false;
+
+    // Import necessary Faust modules and data
+    const { FaustMonoDspGenerator, FaustPolyDspGenerator } = await import("./faustwasm/index.js");
+
+    // Load DSP metadata from JSON
+    /** @type {FaustDspMeta} */
+    const dspMeta = await (await fetch("./dsp-meta.json")).json();
+
+    // Compile the DSP module from WebAssembly binary data
+    const dspModule = await WebAssembly.compileStreaming(await fetch("./dsp-module.wasm"));
+
+    // Create an object representing Faust DSP with metadata and module
+    /** @type {FaustDspDistribution} */
+    const faustDsp = { dspMeta, dspModule };
+
+    /** @type {FaustNode | null} */
+    let faustNode = null;
+
+    // Create either a polyphonic or monophonic Faust audio node based on the number of voices
+    if (voices > 0) {
+
+        // Try to load optional mixer and effect modules
+        faustDsp.mixerModule = await WebAssembly.compileStreaming(await fetch("./mixer-module.wasm"));
+
+        if (FAUST_DSP_HAS_EFFECT) {
+            faustDsp.effectMeta = await (await fetch("./effect-meta.json")).json();
+            faustDsp.effectModule = await WebAssembly.compileStreaming(await fetch("./effect-module.wasm"));
+        }
+
+        // Create a polyphonic Faust audio node
+        const generator = new FaustPolyDspGenerator();
+        faustNode = await generator.createNode(
+            audioContext,
+            voices,
+            dspName,
+            { module: faustDsp.dspModule, json: JSON.stringify(faustDsp.dspMeta), soundfiles: {} },
+            faustDsp.mixerModule,
+            faustDsp.effectModule ? { module: faustDsp.effectModule, json: JSON.stringify(faustDsp.effectMeta), soundfiles: {} } : undefined,
+            sp,
+            bufferSize
+        );
+    } else {
+        // Create a standard Faust audio node
+        const generator = new FaustMonoDspGenerator();
+        faustNode = await generator.createNode(
+            audioContext,
+            dspName,
+            { module: faustDsp.dspModule, json: JSON.stringify(faustDsp.dspMeta), soundfiles: {} },
+            sp,
+            bufferSize
+        );
+    }
+
+    // Return an object with the Faust audio node and the DSP metadata
+    return { faustNode, dspMeta };
+}
+
+/**
+ * Connects an audio input stream to a Faust WebAudio node.
+ * 
+ * @param {AudioContext} audioContext - The Web Audio API AudioContext to which the Faust audio node is connected.
+ * @param {string} id - The ID of the audio input device to connect.
+ * @param {FaustNode} faustNode - The Faust audio node to which the audio input stream will be connected.
+ * @param {MediaStreamAudioSourceNode} oldInputStreamNode - The old audio input stream node to be disconnected from the Faust audio node.
+ * @returns {Promise<MediaStreamAudioSourceNode>} - The new audio input stream node connected to the Faust audio node.
+ */
+async function connectToAudioInput(audioContext, id, faustNode, oldInputStreamNode) {
+    // Create an audio input stream node
+    const constraints = {
+        audio: {
+            echoCancellation: false,
+            noiseSuppression: false,
+            autoGainControl: false,
+            deviceId: id ? { exact: id } : undefined,
+        },
+    };
+    // Get the audio input stream
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    if (stream) {
+        if (oldInputStreamNode) oldInputStreamNode.disconnect();
+        const newInputStreamNode = audioContext.createMediaStreamSource(stream);
+        newInputStreamNode.connect(faustNode);
+        return newInputStreamNode;
+    } else {
+        return oldInputStreamNode;
+    }
+};
+
+/**
+ * Creates a Faust UI for a Faust audio node.
+ * 
+ * @param {FaustAudioWorkletNode} faustNode 
+ */
+async function createFaustUI(divFaustUI, faustNode) {
+    const { FaustUI } = await import("./faust-ui/index.js");
+    const $container = document.createElement("div");
+    $container.style.margin = "0";
+    $container.style.position = "absolute";
+    $container.style.overflow = "auto";
+    $container.style.display = "flex";
+    $container.style.flexDirection = "column";
+    $container.style.width = "100%";
+    $container.style.height = "100%";
+    divFaustUI.appendChild($container);
+    const faustUI = new FaustUI({
+        ui: faustNode.getUI(),
+        root: $container,
+        listenWindowMessage: false,
+        listenWindowResize: true,
+    });
+    faustUI.paramChangeByUI = (path, value) => faustNode.setParamValue(path, value);
+    faustNode.setOutputParamHandler((path, value) => faustUI.paramChangeByDSP(path, value));
+    $container.style.minWidth = `${faustUI.minWidth}px`;
+    $container.style.minHeight = `${faustUI.minHeight}px`;
+    faustUI.resize();
+};
+
+/**
+ * Request permission to use motion and orientation sensors.
+ */
+async function requestPermissions() {
+
+    // Explicitly request permission on iOS before calling startSensors()
+    if (typeof window.DeviceMotionEvent !== "undefined" && typeof window.DeviceMotionEvent.requestPermission === "function") {
+        try {
+            const permissionState = await window.DeviceMotionEvent.requestPermission();
+            if (permissionState !== "granted") {
+                console.warn("Motion sensor permission denied.");
+            } else {
+                console.log("Motion sensor permission granted.");
+            }
+        } catch (error) {
+            console.error("Error requesting motion sensor permission:", error);
+        }
+    }
+
+    if (typeof window.DeviceOrientationEvent !== "undefined" && typeof window.DeviceOrientationEvent.requestPermission === "function") {
+        try {
+            const permissionState = await window.DeviceOrientationEvent.requestPermission();
+            if (permissionState !== "granted") {
+                console.warn("Orientation sensor permission denied.");
+            } else {
+                console.log("Orientation sensor permission granted.");
+            }
+        } catch (error) {
+            console.error("Error requesting orientation sensor permission:", error);
+        }
+    }
+}
+
+/**
+ * Key2Midi: maps keyboard input to MIDI messages.
+ */
+class Key2Midi {
+    static KEY_MAP = {
+        a: 0, w: 1, s: 2, e: 3, d: 4, f: 5, t: 6, g: 7,
+        y: 8, h: 9, u: 10, j: 11, k: 12, o: 13, l: 14, p: 15, ";": 16,
+        z: "PREV", x: "NEXT", c: "VELDOWN", v: "VELUP"
+    };
+
+    constructor({ keyMap = Key2Midi.KEY_MAP, offset = 60, velocity = 100, handler = console.log } = {}) {
+        this.keyMap = keyMap;
+        this.offset = offset;
+        this.velocity = velocity;
+        this.velMap = [20, 40, 60, 80, 100, 127];
+        this.handler = handler;
+        this.pressed = {};
+
+        this.onKeyDown = this.onKeyDown.bind(this);
+        this.onKeyUp = this.onKeyUp.bind(this);
+    }
+
+    start() {
+        window.addEventListener("keydown", this.onKeyDown);
+        window.addEventListener("keyup", this.onKeyUp);
+    }
+
+    stop() {
+        window.removeEventListener("keydown", this.onKeyDown);
+        window.removeEventListener("keyup", this.onKeyUp);
+    }
+
+    onKeyDown(e) {
+        const key = e.key.toLowerCase();
+        if (this.pressed[key]) return;
+        this.pressed[key] = true;
+
+        const val = this.keyMap[key];
+        if (typeof val === "number") {
+            const note = val + this.offset;
+            this.handler([0x90, note, this.velocity]);
+        } else if (val === "PREV") {
+            this.offset -= 1;
+        } else if (val === "NEXT") {
+            this.offset += 1;
+        } else if (val === "VELDOWN") {
+            const idx = Math.max(0, this.velMap.indexOf(this.velocity) - 1);
+            this.velocity = this.velMap[idx];
+        } else if (val === "VELUP") {
+            const idx = Math.min(this.velMap.length - 1, this.velMap.indexOf(this.velocity) + 1);
+            this.velocity = this.velMap[idx];
+        }
+    }
+
+    onKeyUp(e) {
+        const key = e.key.toLowerCase();
+        const val = this.keyMap[key];
+        if (typeof val === "number") {
+            const note = val + this.offset;
+            this.handler([0x80, note, this.velocity]);
+        }
+        delete this.pressed[key];
+    }
+}
+
+/**
+ * Creates a Key2Midi instance.
+ * 
+ * @param {function} handler - The function to handle MIDI messages.
+ * @returns {Key2Midi} - The Key2Midi instance.
+ */
+function createKey2MIDI(handler) {
+    return new Key2Midi({ handler: handler });
+}
+
+// Export the functions
+export { createFaustNode, createFaustUI, createKey2MIDI, connectToAudioInput, requestPermissions };
+