@grame/faustwasm 0.12.1 → 0.13.0

package/src/FaustDspGenerator.ts

@@ -1,22 +1,58 @@
-import { FaustMonoAudioWorkletNode, FaustPolyAudioWorkletNode } from "./FaustAudioWorkletNode";
-import getFaustAudioWorkletProcessor, { FaustData } from "./FaustAudioWorkletProcessor";
-import getFaustFFTAudioWorkletProcessor, { FaustFFTData, FaustFFTOptionsData } from "./FaustFFTAudioWorkletProcessor";
-import { FaustDspInstance } from "./FaustDspInstance";
-import FaustWasmInstantiator from "./FaustWasmInstantiator";
-import { FaustMonoOfflineProcessor, FaustPolyOfflineProcessor, IFaustMonoOfflineProcessor, IFaustPolyOfflineProcessor } from "./FaustOfflineProcessor";
-import { FaustMonoScriptProcessorNode, FaustPolyScriptProcessorNode } from "./FaustScriptProcessorNode";
-import { FaustBaseWebAudioDsp, FaustMonoWebAudioDsp, FaustPolyWebAudioDsp, FaustWebAudioDspVoice, IFaustMonoWebAudioNode, IFaustPolyWebAudioNode, Soundfile, WasmAllocator } from "./FaustWebAudioDsp";
-import SoundfileReader from "./SoundfileReader";
-import FaustSensors from "./FaustSensors";
-import type { IFaustCompiler } from "./FaustCompiler";
-import type { FaustDspFactory, FaustUIDescriptor, FaustDspMeta, FFTUtils, LooseFaustDspFactory, AudioData } from "./types";
-import { FaustAudioWorkletCommunicator, FaustAudioWorkletProcessorCommunicator } from "./FaustAudioWorkletCommunicator";
-
+import {
+    FaustMonoAudioWorkletNode,
+    FaustPolyAudioWorkletNode
+} from './FaustAudioWorkletNode';
+import getFaustAudioWorkletProcessor, {
+    FaustData
+} from './FaustAudioWorkletProcessor';
+import getFaustFFTAudioWorkletProcessor, {
+    FaustFFTData,
+    FaustFFTOptionsData
+} from './FaustFFTAudioWorkletProcessor';
+import { FaustDspInstance } from './FaustDspInstance';
+import FaustWasmInstantiator from './FaustWasmInstantiator';
+import {
+    FaustMonoOfflineProcessor,
+    FaustPolyOfflineProcessor,
+    IFaustMonoOfflineProcessor,
+    IFaustPolyOfflineProcessor
+} from './FaustOfflineProcessor';
+import {
+    FaustMonoScriptProcessorNode,
+    FaustPolyScriptProcessorNode
+} from './FaustScriptProcessorNode';
+import {
+    FaustBaseWebAudioDsp,
+    FaustMonoWebAudioDsp,
+    FaustPolyWebAudioDsp,
+    FaustWebAudioDspVoice,
+    IFaustMonoWebAudioNode,
+    IFaustPolyWebAudioNode,
+    Soundfile,
+    WasmAllocator
+} from './FaustWebAudioDsp';
+import SoundfileReader from './SoundfileReader';
+import FaustSensors from './FaustSensors';
+import FaustCompiler, { IFaustCompiler } from './FaustCompiler';
+import type {
+    FaustDspFactory,
+    FaustUIDescriptor,
+    FaustDspMeta,
+    FFTUtils,
+    LooseFaustDspFactory,
+    AudioData
+} from './types';
+import {
+    FaustAudioWorkletCommunicator,
+    FaustAudioWorkletProcessorCommunicator
+} from './FaustAudioWorkletCommunicator';
+import instantiateFaustModuleFromFile from './instantiateFaustModuleFromFile';
+import LibFaust from './LibFaust';
 
 export interface GeneratorSupportingSoundfiles {
     /**
      * Attach a map of id - audio data, call after `compile()` before `createNode()`
-     * 
+     *
      * @param soundfileMap a map of id - `AudioData` as an object where `AudioData` contains channel data as `audioBuffer: Float32Array[]` and `sampleRate: number`
      */
     addSoundfiles(soundfileMap: Record<string, AudioData>): void;
@@ -27,17 +63,43 @@ export interface GeneratorSupportingSoundfiles {
     getSoundfileList(): string[];
 }
 
+export interface IFaustDspGenerator {
+    /**
+     * Create a monophonic or polyphonic WebAudio node (either ScriptProcessorNode or AudioWorkletNode).
+     * Analyze the code to decide whether to create a monophonic or polyphonic node.
+     *
+     * @param context - the WebAudio context
+     * @param name - DSP name, can be used for processorName
+     * @param code - the DSP code
+     * @param sp - whether to compile a ScriptProcessorNode or an AudioWorkletNode
+     * @param bufferSize - the buffer size in frames to be used in ScriptProcessorNode only, since AudioWorkletNode always uses 128 frames
+     * @returns the compiled monophonic or polyphonic WebAudio node or 'null' if failure
+     */
+    createFaustNode(
+        context: BaseAudioContext,
+        name: string,
+        code: string,
+        sp?: boolean,
+        bufferSize?: number,
+    ): Promise<IFaustMonoWebAudioNode | IFaustPolyWebAudioNode | null>;
+}
+
 export interface IFaustMonoDspGenerator extends GeneratorSupportingSoundfiles {
     /**
      * Compile a monophonic DSP factory from given code.
-     * 
+     *
      * @param compiler - the Faust compiler
      * @param name - the DSP name
      * @param code - the DSP code
      * @param args - the compilation parameters
      * @returns the compiled factory or 'null' if failure
      */
-    compile(compiler: IFaustCompiler, name: string, code: string, args: string): Promise<{
+    compile(
+        compiler: IFaustCompiler,
+        name: string,
+        code: string,
+        args: string
+    ): Promise<{
         factory: FaustDspFactory | null;
         name?: string;
         meta?: FaustDspMeta;
@@ -128,7 +190,7 @@ export interface IFaustMonoDspGenerator extends GeneratorSupportingSoundfiles {
 export interface IFaustPolyDspGenerator extends GeneratorSupportingSoundfiles {
     /**
      * Compile a monophonic DSP factory from given code.
-     * 
+     *
      * @param compiler - the Faust compiler
      * @param name - the DSP name
      * @param dspCode - the DSP code ('dspCode' can possibly contain an integrated effect)
@@ -136,7 +198,13 @@ export interface IFaustPolyDspGenerator extends GeneratorSupportingSoundfiles {
      * @param effectCode - optional effect DSP code
      * @returns the compiled factory or 'null' if failure
      */
-    compile(compiler: IFaustCompiler, name: string, dspCode: string, args: string, effectCode?: string): Promise<{
+    compile(
+        compiler: IFaustCompiler,
+        name: string,
+        dspCode: string,
+        args: string,
+        effectCode?: string
+    ): Promise<{
         voiceFactory: FaustDspFactory | null;
         effectFactory?: FaustDspFactory | null;
     } | null>;
@@ -213,7 +281,8 @@ export interface IFaustPolyDspGenerator extends GeneratorSupportingSoundfiles {
 
 export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
     // Set of all created WorkletProcessors, each of them has to be unique
-    private static gWorkletProcessors: Map<BaseAudioContext, Set<string>> = new Map();
+    private static gWorkletProcessors: Map<BaseAudioContext, Set<string>> =
+        new Map();
 
     name: string;
     factory!: FaustDspFactory | null;
@@ -221,7 +290,12 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
     constructor() {
         this.factory = null;
     }
-    async compile(compiler: IFaustCompiler, name: string, code: string, args: string) {
+    async compile(
+        compiler: IFaustCompiler,
+        name: string,
+        code: string,
+        args: string
+    ) {
         this.factory = await compiler.createMonoDSPFactory(name, code, args);
         if (this.factory) {
             this.name = name;
@@ -232,15 +306,22 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
     }
 
     addSoundfiles(soundfileMap: Record<string, AudioData>) {
-        if (!this.factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!this.factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
         for (const id in soundfileMap) {
             this.factory.soundfiles[id] = soundfileMap[id];
         }
     }
     getSoundfileList() {
-        if (!this.factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!this.factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
         const meta = JSON.parse(this.factory.json);
         const map = SoundfileReader.findSoundfilesFromMeta(meta);
+        if (!map) return [];
         return Object.keys(map);
     }
 
@@ -252,24 +333,56 @@ export class FaustMonoDspGenerator implements IFaustMonoDspGenerator {
         bufferSize = 1024,
         processorName = factory?.shaKey || name,
         processorOptions: Record<string, any> = {}
-    ): Promise<SP extends true ? FaustMonoScriptProcessorNode | null : FaustMonoAudioWorkletNode | null> {
-        if (!factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+    ): Promise<
+        SP extends true
+            ? FaustMonoScriptProcessorNode | null
+            : FaustMonoAudioWorkletNode | null
+    > {
+        if (!factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const meta = JSON.parse(factory.json);
-        const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
-        factory.soundfiles = await SoundfileReader.loadSoundfiles(meta, factory.soundfiles || {}, context);
+        const sampleSize = meta.compile_options.match('-double') ? 8 : 4;
+        factory.soundfiles = await SoundfileReader.loadSoundfiles(
+            meta,
+            factory.soundfiles || {},
+            context
+        );
         if (sp) {
-            const instance = await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
-            const monoDsp = new FaustMonoWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize, factory.soundfiles);
+            const instance =
+                await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
+            const monoDsp = new FaustMonoWebAudioDsp(
+                instance,
+                context.sampleRate,
+                sampleSize,
+                bufferSize,
+                factory.soundfiles
+            );
 
-            const sp = context.createScriptProcessor(bufferSize, monoDsp.getNumInputs(), monoDsp.getNumOutputs()) as FaustMonoScriptProcessorNode;
+            const sp = context.createScriptProcessor(
+                bufferSize,
+                monoDsp.getNumInputs(),
+                monoDsp.getNumOutputs()
+            ) as FaustMonoScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustMonoScriptProcessorNode.prototype);
             sp.init(monoDsp);
-            return sp as SP extends true ? FaustMonoScriptProcessorNode : FaustMonoAudioWorkletNode;
+            return sp as SP extends true
+                ? FaustMonoScriptProcessorNode
+                : FaustMonoAudioWorkletNode;
         } else {
             // Dynamically create AudioWorkletProcessor if code not yet created
-            if (!FaustMonoDspGenerator.gWorkletProcessors.has(context)) FaustMonoDspGenerator.gWorkletProcessors.set(context, new Set());
-            if (!FaustMonoDspGenerator.gWorkletProcessors.get(context)?.has(processorName)) {
+            if (!FaustMonoDspGenerator.gWorkletProcessors.has(context))
+                FaustMonoDspGenerator.gWorkletProcessors.set(
+                    context,
+                    new Set()
+                );
+            if (
+                !FaustMonoDspGenerator.gWorkletProcessors
+                    .get(context)
+                    ?.has(processorName)
+            ) {
                 try {
                     const processorCode = `
 // DSP name and JSON string for DSP are generated
@@ -308,10 +421,14 @@ const dependencies = {
 // Generate the actual AudioWorkletProcessor code
 (${getFaustAudioWorkletProcessor.toString()})(dependencies, faustData);
 `;
-                    const url = URL.createObjectURL(new Blob([processorCode], { type: "text/javascript" }));
+                    const url = URL.createObjectURL(
+                        new Blob([processorCode], { type: 'text/javascript' })
+                    );
                     await context.audioWorklet.addModule(url);
                     // Keep the DSP name
-                    FaustMonoDspGenerator.gWorkletProcessors.get(context)?.add(processorName);
+                    FaustMonoDspGenerator.gWorkletProcessors
+                        .get(context)
+                        ?.add(processorName);
                 } catch (e) {
                     // console.error(`=> exception raised while running createMonoNode: ${e}`);
                     // console.error(`=> check that your page is served using https.${e}`);
@@ -319,9 +436,18 @@ const dependencies = {
                 }
             }
             // Create the AWN
-            const node = new FaustMonoAudioWorkletNode(context, { processorOptions: { name: processorName, factory, sampleSize, ...processorOptions } });
+            const node = new FaustMonoAudioWorkletNode(context, {
+                processorOptions: {
+                    name: processorName,
+                    factory,
+                    sampleSize,
+                    ...processorOptions
+                }
+            });
 
-            return node as SP extends true ? FaustMonoScriptProcessorNode : FaustMonoAudioWorkletNode;
+            return node as SP extends true
+                ? FaustMonoScriptProcessorNode
+                : FaustMonoAudioWorkletNode;
         }
     }
 
@@ -334,14 +460,26 @@ const dependencies = {
         processorName = factory?.shaKey ? `${factory.shaKey}_fft` : name,
         processorOptions: Record<string, any> = {}
     ): Promise<FaustMonoAudioWorkletNode | null> {
-        if (!factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const meta: FaustDspMeta = JSON.parse(factory.json);
-        const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
-        factory.soundfiles = await SoundfileReader.loadSoundfiles(meta, factory.soundfiles || {}, context);
+        const sampleSize = meta.compile_options.match('-double') ? 8 : 4;
+        factory.soundfiles = await SoundfileReader.loadSoundfiles(
+            meta,
+            factory.soundfiles || {},
+            context
+        );
         // Dynamically create AudioWorkletProcessor if code not yet created
-        if (!FaustMonoDspGenerator.gWorkletProcessors.has(context)) FaustMonoDspGenerator.gWorkletProcessors.set(context, new Set());
-        if (!FaustMonoDspGenerator.gWorkletProcessors.get(context)?.has(processorName)) {
+        if (!FaustMonoDspGenerator.gWorkletProcessors.has(context))
+            FaustMonoDspGenerator.gWorkletProcessors.set(context, new Set());
+        if (
+            !FaustMonoDspGenerator.gWorkletProcessors
+                .get(context)
+                ?.has(processorName)
+        ) {
             try {
                 const processorCode = `
 // DSP name and JSON string for DSP are generated
@@ -382,10 +520,14 @@ const dependencies = {
 // Generate the actual AudioWorkletProcessor code
 (${getFaustFFTAudioWorkletProcessor.toString()})(dependencies, faustData);
 `;
-                const url = URL.createObjectURL(new Blob([processorCode], { type: "text/javascript" }));
+                const url = URL.createObjectURL(
+                    new Blob([processorCode], { type: 'text/javascript' })
+                );
                 await context.audioWorklet.addModule(url);
                 // Keep the DSP name
-                FaustMonoDspGenerator.gWorkletProcessors.get(context)?.add(processorName);
+                FaustMonoDspGenerator.gWorkletProcessors
+                    .get(context)
+                    ?.add(processorName);
             } catch (e) {
                 // console.error(`=> exception raised while running createMonoNode: ${e}`);
                 // console.error(`=> check that your page is served using https.${e}`);
@@ -393,21 +535,30 @@ const dependencies = {
             }
         }
         // Create the AWN
-        const node = new FaustMonoAudioWorkletNode(context, { channelCount: Math.max(1, Math.ceil(meta.inputs / 3)), outputChannelCount: [Math.ceil(meta.outputs / 2)], processorOptions: { name: processorName, factory, sampleSize, ...processorOptions } });
+        const node = new FaustMonoAudioWorkletNode(context, {
+            channelCount: Math.max(1, Math.ceil(meta.inputs / 3)),
+            outputChannelCount: [Math.ceil(meta.outputs / 2)],
+            processorOptions: {
+                name: processorName,
+                factory,
+                sampleSize,
+                ...processorOptions
+            }
+        });
         if (fftOptions.fftSize) {
-            const param = node.parameters.get("fftSize");
+            const param = node.parameters.get('fftSize');
             if (param) param.value = fftOptions.fftSize;
         }
         if (fftOptions.fftOverlap) {
-            const param = node.parameters.get("fftOverlap");
+            const param = node.parameters.get('fftOverlap');
             if (param) param.value = fftOptions.fftOverlap;
         }
-        if (typeof fftOptions.defaultWindowFunction === "number") {
-            const param = node.parameters.get("windowFunction");
+        if (typeof fftOptions.defaultWindowFunction === 'number') {
+            const param = node.parameters.get('windowFunction');
             if (param) param.value = fftOptions.defaultWindowFunction + 1;
         }
-        if (typeof fftOptions.noIFFT === "boolean") {
-            const param = node.parameters.get("noIFFT");
+        if (typeof fftOptions.noIFFT === 'boolean') {
+            const param = node.parameters.get('noIFFT');
             if (param) param.value = +fftOptions.noIFFT;
         }
         return node;
@@ -418,7 +569,10 @@ const dependencies = {
         factory = this.factory as LooseFaustDspFactory,
         processorName = factory?.shaKey || name
     ) {
-        if (!factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const meta = JSON.parse(factory.json);
         const dependencies = {
@@ -427,8 +581,8 @@ const dependencies = {
             FaustWasmInstantiator,
             FaustAudioWorkletProcessorCommunicator,
             FaustPolyWebAudioDsp: undefined,
-            FaustWebAudioDspVoice: undefined,
-        }
+            FaustWebAudioDspVoice: undefined
+        };
         // const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
         // Dynamically create AudioWorkletProcessor if code not yet created
         try {
@@ -440,7 +594,10 @@ const dependencies = {
                 poly: false
             } as FaustData;
             // Generate the actual AudioWorkletProcessor code
-            const Processor = getFaustAudioWorkletProcessor(dependencies, faustData);
+            const Processor = getFaustAudioWorkletProcessor(
+                dependencies,
+                faustData
+            );
             return Processor;
         } catch (e) {
             // console.error(`=> exception raised while running createMonoNode: ${e}`);
@@ -455,24 +612,46 @@ const dependencies = {
         factory = this.factory as LooseFaustDspFactory,
         context?: BaseAudioContext
     ) {
-        if (!factory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!factory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const meta = JSON.parse(factory.json);
-        const instance = await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
-        const sampleSize = meta.compile_options.match("-double") ? 8 : 4;
-        if (context) factory.soundfiles = await SoundfileReader.loadSoundfiles(meta, factory.soundfiles || {}, context);
-        const monoDsp = new FaustMonoWebAudioDsp(instance, sampleRate, sampleSize, bufferSize, factory.soundfiles);
+        const instance =
+            await FaustWasmInstantiator.createAsyncMonoDSPInstance(factory);
+        const sampleSize = meta.compile_options.match('-double') ? 8 : 4;
+        if (context)
+            factory.soundfiles = await SoundfileReader.loadSoundfiles(
+                meta,
+                factory.soundfiles || {},
+                context
+            );
+        const monoDsp = new FaustMonoWebAudioDsp(
+            instance,
+            sampleRate,
+            sampleSize,
+            bufferSize,
+            factory.soundfiles
+        );
         return new FaustMonoOfflineProcessor(monoDsp, bufferSize);
     }
 
-    getMeta() { return JSON.parse(this.factory!.json); }
-    getJSON() { return JSON.stringify(this.getMeta()); }
-    getUI() { return this.getMeta().ui; }
+    getMeta() {
+        return JSON.parse(this.factory!.json);
+    }
+    getJSON() {
+        return JSON.stringify(this.getMeta());
+    }
+    getUI() {
+        return this.getMeta().ui;
+    }
 }
 
 export class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
     // Set of all created WorkletProcessors, each of them has to be unique
-    private static gWorkletProcessors: Map<BaseAudioContext, Set<string>> = new Map();
+    private static gWorkletProcessors: Map<BaseAudioContext, Set<string>> =
+        new Map();
 
     name: string;
     voiceFactory!: FaustDspFactory | null;
@@ -489,7 +668,7 @@ export class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
         name: string,
         dspCodeAux: string,
         args: string,
-        // The ${dspCode} has to be added with wrapping new lines to make it properly formatted and ready to compile  
+        // The ${dspCode} has to be added with wrapping new lines to make it properly formatted and ready to compile
         effectCodeAux = `dsp_code = environment{
                 ${dspCodeAux}
             };
@@ -497,8 +676,12 @@ export class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
     ) {
         // Try to compile effect, possibly failing
         try {
-            this.effectFactory = await compiler.createPolyDSPFactory(name, effectCodeAux, args);
-            // Since the effect is processing the same buffers for inputs and outputs (in place processing), 
+            this.effectFactory = await compiler.createPolyDSPFactory(
+                name,
+                effectCodeAux,
+                args
+            );
+            // Since the effect is processing the same buffers for inputs and outputs (in place processing),
             // the voice and effect are adapted, possibly clearing buffers
             if (this.effectFactory) {
                 const effectJSON = JSON.parse(this.effectFactory.json);
@@ -541,24 +724,37 @@ dsp_code = environment{
 };
 process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;
 `;
-                this.voiceFactory = await compiler.createPolyDSPFactory(name, dspCode, args);
+                this.voiceFactory = await compiler.createPolyDSPFactory(
+                    name,
+                    dspCode,
+                    args
+                );
                 try {
                     // Effect is processing same buffers for inputs and outputs, so has to use -inpl option
-                    this.effectFactory = await compiler.createPolyDSPFactory(name, effectCode, args + " -inpl");
+                    this.effectFactory = await compiler.createPolyDSPFactory(
+                        name,
+                        effectCode,
+                        args + ' -inpl'
+                    );
                 } catch (e) {
                     console.warn(e);
                 }
             }
         } catch (e) {
             console.warn(e);
-            this.voiceFactory = await compiler.createPolyDSPFactory(name, dspCodeAux, args);
+            this.voiceFactory = await compiler.createPolyDSPFactory(
+                name,
+                dspCodeAux,
+                args
+            );
         }
 
         if (this.voiceFactory) {
             this.name = name;
             const voiceMeta = JSON.parse(this.voiceFactory.json);
-            const isDouble = voiceMeta.compile_options.match("-double");
-            const { mixerBuffer, mixerModule } = await compiler.getAsyncInternalMixerModule(!!isDouble);
+            const isDouble = voiceMeta.compile_options.match('-double');
+            const { mixerBuffer, mixerModule } =
+                await compiler.getAsyncInternalMixerModule(!!isDouble);
             this.mixerBuffer = mixerBuffer;
             this.mixerModule = mixerModule;
             return this;
@@ -568,15 +764,22 @@ process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;
     }
 
     addSoundfiles(soundfileMap: Record<string, AudioData>) {
-        if (!this.voiceFactory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!this.voiceFactory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
         for (const id in soundfileMap) {
             this.voiceFactory.soundfiles[id] = soundfileMap[id];
         }
     }
     getSoundfileList() {
-        if (!this.voiceFactory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!this.voiceFactory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
         const meta = JSON.parse(this.voiceFactory.json);
         const map = SoundfileReader.findSoundfilesFromMeta(meta);
+        if (!map) return [];
         if (!this.effectFactory) return Object.keys(map);
         const effectMeta = JSON.parse(this.effectFactory.json);
         const effectMap = SoundfileReader.findSoundfilesFromMeta(effectMeta);
@@ -592,29 +795,77 @@ process = adaptorIns(dsp_code.process) : dsp_code.effect : adaptorOuts;
         effectFactory = this.effectFactory as LooseFaustDspFactory | null,
         sp = false as SP,
         bufferSize = 1024,
-        processorName = ((voiceFactory?.shaKey || "") + (effectFactory?.shaKey || "")) || `${name}_poly`,
+        processorName = (voiceFactory?.shaKey || '') +
+            (effectFactory?.shaKey || '') || `${name}_poly`,
         processorOptions = {}
-    ): Promise<SP extends true ? FaustPolyScriptProcessorNode | null : FaustPolyAudioWorkletNode | null> {
-        if (!voiceFactory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+    ): Promise<
+        SP extends true
+            ? FaustPolyScriptProcessorNode | null
+            : FaustPolyAudioWorkletNode | null
+    > {
+        if (!voiceFactory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const voiceMeta = JSON.parse(voiceFactory.json);
-        const effectMeta = effectFactory ? JSON.parse(effectFactory.json) : undefined;
-        const sampleSize = voiceMeta.compile_options.match("-double") ? 8 : 4;
-        voiceFactory.soundfiles = await SoundfileReader.loadSoundfiles(voiceMeta, voiceFactory.soundfiles || {}, context);
-        if (effectFactory) effectFactory.soundfiles = await SoundfileReader.loadSoundfiles(effectMeta, effectFactory.soundfiles || {}, context);
+        const effectMeta = effectFactory
+            ? JSON.parse(effectFactory.json)
+            : undefined;
+        const sampleSize = voiceMeta.compile_options.match('-double') ? 8 : 4;
+        voiceFactory.soundfiles = await SoundfileReader.loadSoundfiles(
+            voiceMeta,
+            voiceFactory.soundfiles || {},
+            context
+        );
+        if (effectFactory)
+            effectFactory.soundfiles = await SoundfileReader.loadSoundfiles(
+                effectMeta,
+                effectFactory.soundfiles || {},
+                context
+            );
         if (sp) {
-            const instance = await FaustWasmInstantiator.createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory || undefined);
-            const soundfiles = { ...effectFactory?.soundfiles, ...voiceFactory.soundfiles };
-            const polyDsp = new FaustPolyWebAudioDsp(instance, context.sampleRate, sampleSize, bufferSize, soundfiles);
+            const instance =
+                await FaustWasmInstantiator.createAsyncPolyDSPInstance(
+                    voiceFactory,
+                    mixerModule,
+                    voices,
+                    effectFactory || undefined
+                );
+            const soundfiles = {
+                ...effectFactory?.soundfiles,
+                ...voiceFactory.soundfiles
+            };
+            const polyDsp = new FaustPolyWebAudioDsp(
+                instance,
+                context.sampleRate,
+                sampleSize,
+                bufferSize,
+                soundfiles
+            );
 
-            const sp = context.createScriptProcessor(bufferSize, polyDsp.getNumInputs(), polyDsp.getNumOutputs()) as FaustPolyScriptProcessorNode;
+            const sp = context.createScriptProcessor(
+                bufferSize,
+                polyDsp.getNumInputs(),
+                polyDsp.getNumOutputs()
+            ) as FaustPolyScriptProcessorNode;
             Object.setPrototypeOf(sp, FaustPolyScriptProcessorNode.prototype);
             sp.init(polyDsp);
-            return sp as SP extends true ? FaustPolyScriptProcessorNode : FaustPolyAudioWorkletNode;
+            return sp as SP extends true
+                ? FaustPolyScriptProcessorNode
+                : FaustPolyAudioWorkletNode;
         } else {
             // Dynamically create AudioWorkletProcessor if code not yet created
-            if (!FaustPolyDspGenerator.gWorkletProcessors.has(context)) FaustPolyDspGenerator.gWorkletProcessors.set(context, new Set());
-            if (!FaustPolyDspGenerator.gWorkletProcessors.get(context)?.has(processorName)) {
+            if (!FaustPolyDspGenerator.gWorkletProcessors.has(context))
+                FaustPolyDspGenerator.gWorkletProcessors.set(
+                    context,
+                    new Set()
+                );
+            if (
+                !FaustPolyDspGenerator.gWorkletProcessors
+                    .get(context)
+                    ?.has(processorName)
+            ) {
                 try {
                     const processorCode = `
 // DSP name and JSON string for DSP are generated
@@ -656,10 +907,14 @@ const dependencies = {
 // Generate the actual AudioWorkletProcessor code
 (${getFaustAudioWorkletProcessor.toString()})(dependencies, faustData);
 `;
-                    const url = URL.createObjectURL(new Blob([processorCode], { type: "text/javascript" }));
+                    const url = URL.createObjectURL(
+                        new Blob([processorCode], { type: 'text/javascript' })
+                    );
                     await context.audioWorklet.addModule(url);
                     // Keep the DSP name
-                    FaustPolyDspGenerator.gWorkletProcessors.get(context)?.add(processorName);
+                    FaustPolyDspGenerator.gWorkletProcessors
+                        .get(context)
+                        ?.add(processorName);
                 } catch (e) {
                     // console.error(`=> exception raised while running createPolyNode: ${e}`);
                     // console.error(`=> check that your page is served using https.${e}`);
@@ -667,9 +922,21 @@ const dependencies = {
                 }
             }
             // Create the AWN
-            const node = new FaustPolyAudioWorkletNode(context, { processorOptions: { name: processorName, voiceFactory, mixerModule, voices, sampleSize, effectFactory: effectFactory || undefined, ...processorOptions } });
+            const node = new FaustPolyAudioWorkletNode(context, {
+                processorOptions: {
+                    name: processorName,
+                    voiceFactory,
+                    mixerModule,
+                    voices,
+                    sampleSize,
+                    effectFactory: effectFactory || undefined,
+                    ...processorOptions
+                }
+            });
 
-            return node as SP extends true ? FaustPolyScriptProcessorNode : FaustPolyAudioWorkletNode;
+            return node as SP extends true
+                ? FaustPolyScriptProcessorNode
+                : FaustPolyAudioWorkletNode;
         }
     }
 
@@ -677,13 +944,19 @@ const dependencies = {
         name = this.name,
         voiceFactory = this.voiceFactory as LooseFaustDspFactory,
         effectFactory = this.effectFactory as LooseFaustDspFactory | null,
-        processorName = ((voiceFactory?.shaKey || "") + (effectFactory?.shaKey || "")) || `${name}_poly`
+        processorName = (voiceFactory?.shaKey || '') +
+            (effectFactory?.shaKey || '') || `${name}_poly`
     ) {
-        if (!voiceFactory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!voiceFactory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const voiceMeta = JSON.parse(voiceFactory.json);
-        const effectMeta = effectFactory ? JSON.parse(effectFactory.json) : undefined;
-        const sampleSize = voiceMeta.compile_options.match("-double") ? 8 : 4;
+        const effectMeta = effectFactory
+            ? JSON.parse(effectFactory.json)
+            : undefined;
+        const sampleSize = voiceMeta.compile_options.match('-double') ? 8 : 4;
         // Dynamically create AudioWorkletProcessor if code not yet created
         try {
             const dependencies = {
@@ -703,7 +976,10 @@ const dependencies = {
                 effectMeta
             } as FaustData;
             // Generate the actual AudioWorkletProcessor code
-            const Processor = getFaustAudioWorkletProcessor<true>(dependencies, faustData);
+            const Processor = getFaustAudioWorkletProcessor<true>(
+                dependencies,
+                faustData
+            );
             return Processor;
         } catch (e) {
             // console.error(`=> exception raised while running createPolyNode: ${e}`);
@@ -721,38 +997,74 @@ const dependencies = {
         effectFactory = this.effectFactory as LooseFaustDspFactory | null,
         context?: BaseAudioContext
     ) {
-        if (!voiceFactory) throw new Error("Code is not compiled, please define the factory or call `await this.compile()` first.");
+        if (!voiceFactory)
+            throw new Error(
+                'Code is not compiled, please define the factory or call `await this.compile()` first.'
+            );
 
         const voiceMeta = JSON.parse(voiceFactory.json);
-        const effectMeta = effectFactory ? JSON.parse(effectFactory.json) : undefined;
-        const instance = await FaustWasmInstantiator.createAsyncPolyDSPInstance(voiceFactory, mixerModule, voices, effectFactory || undefined);
-        const sampleSize = voiceMeta.compile_options.match("-double") ? 8 : 4;
+        const effectMeta = effectFactory
+            ? JSON.parse(effectFactory.json)
+            : undefined;
+        const instance = await FaustWasmInstantiator.createAsyncPolyDSPInstance(
+            voiceFactory,
+            mixerModule,
+            voices,
+            effectFactory || undefined
+        );
+        const sampleSize = voiceMeta.compile_options.match('-double') ? 8 : 4;
         if (context) {
-            voiceFactory.soundfiles = await SoundfileReader.loadSoundfiles(voiceMeta, voiceFactory.soundfiles || {}, context);
-            if (effectFactory) effectFactory.soundfiles = await SoundfileReader.loadSoundfiles(effectMeta, effectFactory.soundfiles || {}, context);
+            voiceFactory.soundfiles = await SoundfileReader.loadSoundfiles(
+                voiceMeta,
+                voiceFactory.soundfiles || {},
+                context
+            );
+            if (effectFactory)
+                effectFactory.soundfiles = await SoundfileReader.loadSoundfiles(
+                    effectMeta,
+                    effectFactory.soundfiles || {},
+                    context
+                );
         }
-        const soundfiles = { ...effectFactory?.soundfiles, ...voiceFactory.soundfiles };
-        const polyDsp = new FaustPolyWebAudioDsp(instance, sampleRate, sampleSize, bufferSize, soundfiles);
+        const soundfiles = {
+            ...effectFactory?.soundfiles,
+            ...voiceFactory.soundfiles
+        };
+        const polyDsp = new FaustPolyWebAudioDsp(
+            instance,
+            sampleRate,
+            sampleSize,
+            bufferSize,
+            soundfiles
+        );
         return new FaustPolyOfflineProcessor(polyDsp, bufferSize);
     }
 
     getMeta() {
-        const o = (this.voiceFactory) ? JSON.parse(this.voiceFactory.json) : null;
-        const e = (this.effectFactory) ? JSON.parse(this.effectFactory.json) : null;
+        const o = this.voiceFactory ? JSON.parse(this.voiceFactory.json) : null;
+        const e = this.effectFactory
+            ? JSON.parse(this.effectFactory.json)
+            : null;
         const r = { ...o };
         if (e) {
-            r.ui = [{
-                type: "tgroup", label: "Sequencer", items: [
-                    { type: "vgroup", label: "Instrument", items: o.ui },
-                    { type: "vgroup", label: "Effect", items: e.ui }
-                ]
-            }];
+            r.ui = [
+                {
+                    type: 'tgroup',
+                    label: 'Sequencer',
+                    items: [
+                        { type: 'vgroup', label: 'Instrument', items: o.ui },
+                        { type: 'vgroup', label: 'Effect', items: e.ui }
+                    ]
+                }
+            ];
         } else {
-            r.ui = [{
-                type: "tgroup", label: "Polyphonic", items: [
-                    { type: "vgroup", label: "Voices", items: o.ui }
-                ]
-            }];
+            r.ui = [
+                {
+                    type: 'tgroup',
+                    label: 'Polyphonic',
+                    items: [{ type: 'vgroup', label: 'Voices', items: o.ui }]
+                }
+            ];
         }
         return r as FaustDspMeta;
     }
@@ -765,3 +1077,136 @@ const dependencies = {
         return this.getMeta().ui;
     }
 }
+
+interface JSONData {
+    meta: Array<{ options?: string }>;
+}
+
+export class FaustDspGenerator implements IFaustDspGenerator {
+    
+    private static compilerPromise: Promise<FaustCompiler> | null = null;
+    
+    // Analyze the metadata of a Faust JSON file and extract the [midi:on] and [nvoices:n] options
+    private extractMidiAndNvoices(
+        jsonData: JSONData
+    ): { midi: boolean; nvoices: number } {
+        const optionsMetadata = jsonData.meta.find((meta) => meta.options);
+        if (optionsMetadata && optionsMetadata.options) {
+            const options = optionsMetadata.options;
+
+            const midiRegex = /\[midi:(on|off)\]/;
+            const nvoicesRegex = /\[nvoices:(\d+)\]/;
+
+            const midiMatch = options.match(midiRegex);
+            const nvoicesMatch = options.match(nvoicesRegex);
+
+            const midi = midiMatch ? midiMatch[1] === 'on' : false;
+            const nvoices = nvoicesMatch ? parseInt(nvoicesMatch[1], 10) : -1;
+
+            return { midi, nvoices };
+        } else {
+            return { midi: false, nvoices: -1 };
+        }
+    }
+    
+    /**
+     * Compile DSP code, inspect metadata for [nvoices:] (and optionally [midi:on]), and build either a mono
+     * or poly WebAudio node (ScriptProcessor or AudioWorklet depending on `sp`). Compilation uses a shared,
+     * lazily-created libfaust instance to avoid repeatedly instantiating the WASM compiler.
+     */
+    async createFaustNode(
+        context: BaseAudioContext,
+        name: string,
+        code: string,
+        sp?: boolean,
+        bufferSize?: number,
+    ): Promise<IFaustMonoWebAudioNode | IFaustPolyWebAudioNode | null> {
+        const getCompiler = async () => {
+            if (!FaustDspGenerator.compilerPromise) {
+                // Resolve libfaust-wasm assets relative to current script/page location (works in browser and bundlers).
+                // Falling back to document/baseURI keeps things working when import.meta.url is unavailable (es2019 target).
+                const baseURL =
+                    (typeof document !== 'undefined'
+                        ? ('src' in (document.currentScript || {})
+                              ? (document.currentScript as HTMLScriptElement)
+                                    .src
+                              : document.baseURI)
+                        : undefined) ||
+                    (typeof window !== 'undefined'
+                        ? window.location.href
+                        : undefined);
+                if (!baseURL)
+                    throw new Error('Cannot resolve libfaust-wasm location.');
+                const jsURL = new URL(
+                    '../libfaust-wasm/libfaust-wasm.js',
+                    baseURL
+                    ).href;
+                const dataURL = jsURL.replace(/c?js$/, 'data');
+                const wasmURL = jsURL.replace(/c?js$/, 'wasm');
+                FaustDspGenerator.compilerPromise =
+                    instantiateFaustModuleFromFile(
+                        jsURL,
+                        dataURL,
+                        wasmURL
+                    ).then((module) => new FaustCompiler(new LibFaust(module)));
+            }
+            return FaustDspGenerator.compilerPromise;
+        };
+
+        const args = '-ftz 2';
+
+        try {
+            const compiler = await getCompiler();
+            // First compile as mono to inspect metadata for nvoices/midi tags; if nvoices > 0 we recompile as poly.
+            const monoGenerator = new FaustMonoDspGenerator();
+            const compiledMono = await monoGenerator.compile(
+                compiler,
+                name,
+                code,
+                args
+            );
+            if (!compiledMono) return null;
+
+            // Extract nvoices from metadata
+            const { nvoices } = this.extractMidiAndNvoices(
+                monoGenerator.getMeta() as unknown as JSONData
+            );
+
+            // If nvoices > 0, recompile as polyphonic
+            if (nvoices > 0) {
+                const polyGenerator = new FaustPolyDspGenerator();
+                const compiledPoly = await polyGenerator.compile(
+                    compiler,
+                    name,
+                    code,
+                    args
+                );
+                if (!compiledPoly) return null;
+
+                // Poly creation: combine voice/effect factories, create node with requested SP/AWN and buffer size.
+                return await polyGenerator.createNode(
+                    context,
+                    nvoices,
+                    name,
+                    undefined,
+                    undefined,
+                    undefined,
+                    sp,
+                    bufferSize
+                );
+            }
+
+            // Mono creation path when no polyphony hint is present.
+            return await monoGenerator.createNode(
+                context,
+                name,
+                undefined,
+                sp,
+                bufferSize
+            );
+        } catch (e) {
+            console.error(e);
+            return null;
+        }
+    }
+}