@grame/faustwasm 0.12.2 → 0.13.1

package/src/faust2wavFiles.js

@@ -1,7 +1,7 @@
 //@ts-check
-import * as fs from "fs";
-import * as path from "path";
-import * as process from "process";
+import * as fs from 'fs';
+import * as path from 'path';
+import * as process from 'process';
 import {
     instantiateFaustModuleFromFile,
     LibFaust,
@@ -9,8 +9,8 @@ import {
     FaustMonoDspGenerator,
     WavDecoder,
     WavEncoder
-} from "../dist/esm/index.js";
-import { fileURLToPath } from "url";
+} from '../dist/esm/index.js';
+import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const __filename = fileURLToPath(import.meta.url);
@@ -25,18 +25,29 @@ const __filename = fileURLToPath(import.meta.url);
  * @param {number} bitDepth
  * @param {string[]} [argv]
  */
-const faust2wavFiles = async (inputFile, inputWav, outputWav, bufferSize = 64, sampleRate = 44100, samples = 5 * sampleRate, bitDepth = 16, argv = []) => {
-    const faustModule = await instantiateFaustModuleFromFile(path.join(__dirname, "../libfaust-wasm/libfaust-wasm.js"));
+const faust2wavFiles = async (
+    inputFile,
+    inputWav,
+    outputWav,
+    bufferSize = 64,
+    sampleRate = 44100,
+    samples = 5 * sampleRate,
+    bitDepth = 16,
+    argv = []
+) => {
+    const faustModule = await instantiateFaustModuleFromFile(
+        path.join(__dirname, '../libfaust-wasm/libfaust-wasm.js')
+    );
     const libFaust = new LibFaust(faustModule);
     const compiler = new FaustCompiler(libFaust);
     console.log(`Faust Compiler version: ${compiler.version()}`);
     console.log(`Reading file ${inputFile}`);
-    const code = fs.readFileSync(inputFile, { encoding: "utf8" });
+    const code = fs.readFileSync(inputFile, { encoding: 'utf8' });
     const { name } = path.parse(inputFile);
     const gen = new FaustMonoDspGenerator();
-    await gen.compile(compiler, name, code, argv.join(" "));
+    await gen.compile(compiler, name, code, argv.join(' '));
     const processor = await gen.createOfflineProcessor(sampleRate, bufferSize);
-    if (!processor) throw Error("Processor not generated");
+    if (!processor) throw Error('Processor not generated');
     /** @type {Float32Array[] | undefined} */
     let input = undefined;
     if (inputWav) {
@@ -46,8 +57,10 @@ const faust2wavFiles = async (inputFile, inputWav, outputWav, bufferSize = 64, s
         input = WavDecoder.decode(inputBuffer).channelData;
     }
     console.log(`Processing...`);
-    const output = processor.render(input, samples, sample => process.stdout.write(`\r${sample} / ${samples}`));
-    console.log("");
+    const output = processor.render(input, samples, (sample) =>
+        process.stdout.write(`\r${sample} / ${samples}`)
+    );
+    console.log('');
     console.log(`Encoding...`);
     const outputBuffer = WavEncoder.encode(output, { bitDepth, sampleRate });
     console.log(`Writing output wav file ${outputWav}.`);

package/src/index-bundle-iife.ts

@@ -1,7 +1,7 @@
-import * as faustwasm from "./exports-bundle";
+import * as faustwasm from './exports-bundle';
 // export default faustwasm;
 // Bug with dts-bundle-generator
 
-export * from "./exports-bundle";
+export * from './exports-bundle';
 
 (globalThis as any).faustwasm = faustwasm;

package/src/index-bundle.ts

@@ -2,4 +2,4 @@
 // export default faustwasm;
 // Bug with dts-bundle-generator
 
-export * from "./exports-bundle";
+export * from './exports-bundle';

package/src/index.ts

@@ -2,4 +2,4 @@
 // export default faustwasm;
 // Bug with dts-bundle-generator
 
-export * from "./exports";
+export * from './exports';

package/src/instantiateFaustModule.ts

@@ -1,36 +1,43 @@
-import factoryFn from "../libfaust-wasm/libfaust-wasm.cjs";
-import wasmBinary from "../libfaust-wasm/libfaust-wasm.wasm";
-import dataBinary from "../libfaust-wasm/libfaust-wasm.data";
-
-export const FaustModuleFactoryFn = factoryFn;
-export const FaustModuleFactoryWasm = wasmBinary;
-export const FaustModuleFactoryData = dataBinary;
-
-/**
- * Instantiate `FaustModule` using bundled binaries. Module constructor and files can be overriden.
- */
-const instantiateFaustModule = async (FaustModuleFactoryIn = factoryFn, dataBinaryIn = dataBinary, wasmBinaryIn = wasmBinary) => {
-    const g = globalThis as any;
-    if (g.AudioWorkletGlobalScope) {
-        g.importScripts = () => { };
-        g.self = { location: { href: "" } };
-    }
-    const faustModule = await FaustModuleFactoryIn({
-        // Create a copy to guarantee a standard ArrayBuffer
-        wasmBinary: (new Uint8Array(wasmBinaryIn)).buffer,
-        getPreloadedPackage: (remotePackageName: string, remotePackageSize: number) => {
-            if (remotePackageName === "libfaust-wasm.data") {
-                // Create a copy to guarantee a standard ArrayBuffer
-                return (new Uint8Array(dataBinaryIn)).buffer;
-            }
-            return new ArrayBuffer(0);
-        }
-    });
-    if (g.AudioWorkletGlobalScope) {
-        delete g.importScripts;
-        delete g.self;
-    }
-    return faustModule;
-};
-
-export default instantiateFaustModule;
+import factoryFn from '../libfaust-wasm/libfaust-wasm.cjs';
+import wasmBinary from '../libfaust-wasm/libfaust-wasm.wasm';
+import dataBinary from '../libfaust-wasm/libfaust-wasm.data';
+
+export const FaustModuleFactoryFn = factoryFn;
+export const FaustModuleFactoryWasm = wasmBinary;
+export const FaustModuleFactoryData = dataBinary;
+
+/**
+ * Instantiate `FaustModule` using bundled binaries. Module constructor and files can be overriden.
+ */
+const instantiateFaustModule = async (
+    FaustModuleFactoryIn = factoryFn,
+    dataBinaryIn = dataBinary,
+    wasmBinaryIn = wasmBinary
+) => {
+    const g = globalThis as any;
+    if (g.AudioWorkletGlobalScope) {
+        g.importScripts = () => {};
+        g.self = { location: { href: '' } };
+    }
+    const faustModule = await FaustModuleFactoryIn({
+        // Create a copy to guarantee a standard ArrayBuffer
+        wasmBinary: new Uint8Array(wasmBinaryIn).buffer,
+        getPreloadedPackage: (
+            remotePackageName: string,
+            remotePackageSize: number
+        ) => {
+            if (remotePackageName === 'libfaust-wasm.data') {
+                // Create a copy to guarantee a standard ArrayBuffer
+                return new Uint8Array(dataBinaryIn).buffer;
+            }
+            return new ArrayBuffer(0);
+        }
+    });
+    if (g.AudioWorkletGlobalScope) {
+        delete g.importScripts;
+        delete g.self;
+    }
+    return faustModule;
+};
+
+export default instantiateFaustModule;

package/src/instantiateFaustModuleFromFile.ts

@@ -1,4 +1,4 @@
-import type { FaustModuleFactory } from "./types";
+import type { FaustModuleFactory } from './types';
 
 /**
  * Load libfaust-wasm files, than instantiate libFaust
@@ -6,24 +6,31 @@ import type { FaustModuleFactory } from "./types";
  * @param dataFile path to `libfaust-wasm.data`
  * @param wasmFile path to `libfaust-wasm.wasm`
  */
-const instantiateFaustModuleFromFile = async (jsFile: string, dataFile = jsFile.replace(/c?js$/, "data"), wasmFile = jsFile.replace(/c?js$/, "wasm")) => {
+const instantiateFaustModuleFromFile = async (
+    jsFile: string,
+    dataFile = jsFile.replace(/c?js$/, 'data'),
+    wasmFile = jsFile.replace(/c?js$/, 'wasm')
+) => {
     let FaustModule: FaustModuleFactory;
     let dataBinary: ArrayBuffer;
     let wasmBinary: ArrayBuffer;
     const jsCodeHead = /var (.+) = \(/;
-    if (typeof window === "object") {
+    if (typeof window === 'object') {
         let jsCode = await (await fetch(jsFile)).text();
         jsCode = `${jsCode}
 export default ${jsCode.match(jsCodeHead)?.[1]};
 `;
-        const jsFileMod = URL.createObjectURL(new Blob([jsCode], { type: "text/javascript" }));
-        FaustModule = (await import(/* webpackIgnore: true */jsFileMod)).default;
+        const jsFileMod = URL.createObjectURL(
+            new Blob([jsCode], { type: 'text/javascript' })
+        );
+        FaustModule = (await import(/* webpackIgnore: true */ jsFileMod))
+            .default;
         dataBinary = await (await fetch(dataFile)).arrayBuffer();
         wasmBinary = await (await fetch(wasmFile)).arrayBuffer();
     } else {
-        const { promises: fs } = await import("fs");
-        const { pathToFileURL } = await import("url");
-        let jsCode = (await fs.readFile(jsFile, { encoding: "utf-8" }));
+        const { promises: fs } = await import('fs');
+        const { pathToFileURL } = await import('url');
+        let jsCode = await fs.readFile(jsFile, { encoding: 'utf-8' });
         jsCode = `
 import process from "process";
 import * as path from "path";
@@ -38,18 +45,27 @@ ${jsCode}
 
 export default ${jsCode.match(jsCodeHead)?.[1]};
 `;
-        const jsFileMod = jsFile.replace(/c?js$/, "mjs");
+        const jsFileMod = jsFile.replace(/c?js$/, 'mjs');
         await fs.writeFile(jsFileMod, jsCode);
-        FaustModule = (await import(/* webpackIgnore: true */pathToFileURL(jsFileMod).href)).default;
+        FaustModule = (
+            await import(
+                /* webpackIgnore: true */ pathToFileURL(jsFileMod).href
+            )
+        ).default;
         await fs.unlink(jsFileMod);
         // Using a type assertion `as ArrayBuffer` to satisfy the strict type checking.
-        dataBinary = (new Uint8Array(await fs.readFile(dataFile))).buffer as ArrayBuffer;
-        wasmBinary = (new Uint8Array(await fs.readFile(wasmFile))).buffer as ArrayBuffer;
+        dataBinary = new Uint8Array(await fs.readFile(dataFile))
+            .buffer as ArrayBuffer;
+        wasmBinary = new Uint8Array(await fs.readFile(wasmFile))
+            .buffer as ArrayBuffer;
     }
     const faustModule = await FaustModule({
         wasmBinary,
-        getPreloadedPackage: (remotePackageName: string, remotePackageSize: number) => {
-            if (remotePackageName === "libfaust-wasm.data") return dataBinary;
+        getPreloadedPackage: (
+            remotePackageName: string,
+            remotePackageSize: number
+        ) => {
+            if (remotePackageName === 'libfaust-wasm.data') return dataBinary;
             return new ArrayBuffer(0);
         }
     });

package/src/types.ts

@@ -3,8 +3,17 @@ export type FaustModuleFactory = EmscriptenModuleFactory<FaustModule>;
 export interface FaustModule extends EmscriptenModule {
     ccall: typeof ccall;
     cwrap: typeof cwrap;
-    UTF8ArrayToString(u8Array: number[], ptr: number, maxBytesToRead?: number): string;
-    stringToUTF8Array(str: string, outU8Array: number[], outIdx: number, maxBytesToWrite: number): number;
+    UTF8ArrayToString(
+        u8Array: number[],
+        ptr: number,
+        maxBytesToRead?: number
+    ): string;
+    stringToUTF8Array(
+        str: string,
+        outU8Array: number[],
+        outIdx: number,
+        maxBytesToWrite: number
+    ): number;
     UTF8ToString: typeof UTF8ToString;
     UTF16ToString: typeof UTF16ToString;
     UTF32ToString: typeof UTF32ToString;
@@ -19,7 +28,14 @@ export interface FaustModule extends EmscriptenModule {
     libFaustWasm: new () => LibFaustWasm;
 }
 
-export type FaustInfoType = "help" | "version" | "libdir" | "includedir" | "archdir" | "dspdir" | "pathslist";
+export type FaustInfoType =
+    | 'help'
+    | 'version'
+    | 'libdir'
+    | 'includedir'
+    | 'archdir'
+    | 'dspdir'
+    | 'pathslist';
 
 export interface IntVector {
     size(): number;
@@ -39,7 +55,7 @@ export interface FaustDspWasm {
 export interface LibFaustWasm {
     /**
      * Return the Faust compiler version.
-     * 
+     *
      * @returns the version
      */
     version(): string;
@@ -53,7 +69,12 @@ export interface LibFaustWasm {
      * @param useInternalMemory - tell the compiler to generate static embedded memory or not
      * @returns an opaque reference to the factory
      */
-    createDSPFactory(name: string, code: string, args: string, useInternalMemory: boolean): FaustDspWasm;
+    createDSPFactory(
+        name: string,
+        code: string,
+        args: string,
+        useInternalMemory: boolean
+    ): FaustDspWasm;
 
     /**
      * Delete a dsp factory.
@@ -104,7 +125,7 @@ export interface LibFaustWasm {
     getInfos(what: FaustInfoType): string;
 }
 
-export interface FaustDspFactory extends Required<LooseFaustDspFactory> { }
+export type FaustDspFactory = Required<LooseFaustDspFactory>;
 
 /**
  * The Factory structure.
@@ -167,20 +188,29 @@ export interface FaustUIMeta {
     [order: number]: string;
     style?: string; // "knob" | "menu{'Name0':value0;'Name1':value1}" | "radio{'Name0':value0;'Name1':value1}" | "led";
     unit?: string;
-    scale?: "linear" | "exp" | "log";
+    scale?: 'linear' | 'exp' | 'log';
     tooltip?: string;
     hidden?: string;
     [key: string]: string | undefined;
 }
-export type FaustUIGroupType = "vgroup" | "hgroup" | "tgroup";
-export type FaustUIOutputType = "hbargraph" | "vbargraph";
-export type FaustUIInputType = "vslider" | "hslider" | "button" | "checkbox" | "nentry" | "soundfile";
+export type FaustUIGroupType = 'vgroup' | 'hgroup' | 'tgroup';
+export type FaustUIOutputType = 'hbargraph' | 'vbargraph';
+export type FaustUIInputType =
+    | 'vslider'
+    | 'hslider'
+    | 'button'
+    | 'checkbox'
+    | 'nentry'
+    | 'soundfile';
 export interface FaustUIGroup {
     type: FaustUIGroupType;
     label: string;
     items: FaustUIItem[];
 }
-export type FaustUIType = FaustUIGroupType | FaustUIOutputType | FaustUIInputType;
+export type FaustUIType =
+    | FaustUIGroupType
+    | FaustUIOutputType
+    | FaustUIInputType;
 
 export interface AudioParamDescriptor {
     automationRate?: AutomationRate;
@@ -192,18 +222,25 @@ export interface AudioParamDescriptor {
 
 export interface AudioWorkletProcessor {
     port: MessagePort;
-    process(inputs: Float32Array[][], outputs: Float32Array[][], parameters: Record<string, Float32Array>): boolean;
+    process(
+        inputs: Float32Array[][],
+        outputs: Float32Array[][],
+        parameters: Record<string, Float32Array>
+    ): boolean;
 }
 export declare const AudioWorkletProcessor: {
     prototype: AudioWorkletProcessor;
     parameterDescriptors: AudioParamDescriptor[];
-    new(options: AudioWorkletNodeOptions): AudioWorkletProcessor;
+    new (options: AudioWorkletNodeOptions): AudioWorkletProcessor;
 };
 
 export interface AudioWorkletGlobalScope {
     AudioWorkletGlobalScope: any;
     globalThis: AudioWorkletGlobalScope;
-    registerProcessor: (name: string, constructor: new (options: any) => AudioWorkletProcessor) => void;
+    registerProcessor: (
+        name: string,
+        constructor: new (options: any) => AudioWorkletProcessor
+    ) => void;
     currentFrame: number;
     currentTime: number;
     sampleRate: number;
@@ -211,18 +248,44 @@ export interface AudioWorkletGlobalScope {
 }
 
 export interface InterfaceFFT {
-    forward(arr: ArrayLike<number> | ((arr: Float32Array) => any)): Float32Array;
-    inverse(arr: ArrayLike<number> | ((arr: Float32Array) => any)): Float32Array;
+    forward(
+        arr: ArrayLike<number> | ((arr: Float32Array) => any)
+    ): Float32Array;
+    inverse(
+        arr: ArrayLike<number> | ((arr: Float32Array) => any)
+    ): Float32Array;
     dispose(): void;
 }
 export declare const InterfaceFFT: {
-    new(size: number): InterfaceFFT;
-}
+    new (size: number): InterfaceFFT;
+};
 
-export type TWindowFunction = (index: number, length: number, ...args: any[]) => number;
+export type TWindowFunction = (
+    index: number,
+    length: number,
+    ...args: any[]
+) => number;
 export type Writeable<T> = { -readonly [P in keyof T]: T[P] };
-export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
-export type TypedArrayConstructor = typeof Int8Array | typeof Uint8Array | typeof Int16Array | typeof Uint16Array | typeof Int32Array | typeof Uint32Array | typeof Uint8ClampedArray | typeof Float32Array | typeof Float64Array;
+export type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Uint8ClampedArray
+    | Float32Array
+    | Float64Array;
+export type TypedArrayConstructor =
+    | typeof Int8Array
+    | typeof Uint8Array
+    | typeof Int16Array
+    | typeof Uint16Array
+    | typeof Int32Array
+    | typeof Uint32Array
+    | typeof Uint8ClampedArray
+    | typeof Float32Array
+    | typeof Float64Array;
 
 export declare const FFTUtils: {
     /** Inject window functions as array, no need to add rectangular (no windowing) */
@@ -230,12 +293,25 @@ export declare const FFTUtils: {
     /** Get a FFT interface constructor */
     getFFT: () => Promise<typeof InterfaceFFT>;
     /** Convert from FFTed (spectral) signal to three arrays for Faust processor's input, fft is readonly, real/imag/index length = *fftSize* / 2 + 1; fft length depends on the FFT implementation */
-    fftToSignal: (fft: Float32Array | Float64Array, real: Float32Array | Float64Array, imag?: Float32Array | Float64Array, index?: Float32Array | Float64Array) => any;
+    fftToSignal: (
+        fft: Float32Array | Float64Array,
+        real: Float32Array | Float64Array,
+        imag?: Float32Array | Float64Array,
+        index?: Float32Array | Float64Array
+    ) => any;
     /** Convert from Faust processor's output to spectral data for Inversed FFT, real/imag are readonly, real/imag length = *fftSize* / 2 + 1; fft length depends on the FFT implementation */
-    signalToFFT: (real: Float32Array | Float64Array, imag: Float32Array | Float64Array, fft: Float32Array | Float64Array) => any;
+    signalToFFT: (
+        real: Float32Array | Float64Array,
+        imag: Float32Array | Float64Array,
+        fft: Float32Array | Float64Array
+    ) => any;
     /** Convert from Faust processor's output to direct audio output, real/imag are readonly, fft length = fftSize = (real/imag length - 1) * 2 */
-    signalToNoFFT: (real: Float32Array | Float64Array, imag: Float32Array | Float64Array, fft: Float32Array | Float64Array) => any;
-}
+    signalToNoFFT: (
+        real: Float32Array | Float64Array,
+        imag: Float32Array | Float64Array,
+        fft: Float32Array | Float64Array
+    ) => any;
+};
 
 export interface AudioData {
     sampleRate: number;

package/test/faustlive-wasm/faustwasm/index.d.ts

@@ -91,8 +91,7 @@ export interface LibFaustWasm {
 	 */
 	getInfos(what: FaustInfoType): string;
 }
-export interface FaustDspFactory extends Required<LooseFaustDspFactory> {
-}
+export type FaustDspFactory = Required<LooseFaustDspFactory>;
 /**
  * The Factory structure.
  */
@@ -404,7 +403,7 @@ export declare class FaustWasmInstantiator {
 	private static createMemoryMono;
 	private static createMemoryPoly;
 	private static createMixerAux;
-	static loadDSPFactory(wasmPath: string, jsonPath: string): Promise<FaustDspFactory>;
+	static loadDSPFactory(wasmPath: string, jsonPath: string): Promise<Required<LooseFaustDspFactory>>;
 	static loadDSPMixer(mixerPath: string, fs?: typeof FS): Promise<WebAssembly.Module>;
 	static createAsyncMonoDSPInstance(factory: LooseFaustDspFactory): Promise<FaustMonoDspInstance>;
 	static createSyncMonoDSPInstance(factory: LooseFaustDspFactory): FaustMonoDspInstance;
@@ -673,10 +672,10 @@ export interface IFaustBaseWebAudioDsp {
 	 */
 	getUI(): FaustUIDescriptor;
 	/**
-	* Get DSP UI items description.
-	*
-	* @return the DSP UI items description
-	*/
+	 * Get DSP UI items description.
+	 *
+	 * @return the DSP UI items description
+	 */
 	getDescriptors(): FaustUIInputItem[];
 	/**
 	 * Get DSP JSON description with its UI and metadata.
@@ -685,8 +684,8 @@ export interface IFaustBaseWebAudioDsp {
 	 */
 	getJSON(): string;
 	/**
-	* Start accelerometer and gyroscope handlers.
-	*/
+	 * Start accelerometer and gyroscope handlers.
+	 */
 	startSensors(): void;
 	/**
 	 * Stop accelerometer and gyroscope handlers.
@@ -720,8 +719,7 @@ export interface IFaustBaseWebAudioDsp {
 	 */
 	destroy(): void;
 }
-export interface IFaustMonoWebAudioDsp extends IFaustBaseWebAudioDsp {
-}
+export type IFaustMonoWebAudioDsp = IFaustBaseWebAudioDsp;
 export interface IFaustMonoWebAudioNode extends IFaustMonoWebAudioDsp, AudioNode {
 }
 export interface IFaustPolyWebAudioDsp extends IFaustBaseWebAudioDsp {
@@ -849,7 +847,7 @@ export declare class FaustBaseWebAudioDsp implements IFaustBaseWebAudioDsp {
 	 *
 	 * @param allocator : the wasm memory allocator
 	 * @param baseDSP : the DSP struct (either a monophonic DSP of polyphonic voice) base DSP in the wasm memory
-	*/
+	 */
 	protected initSoundfileMemory(allocator: WasmAllocator, baseDSP: number): void;
 	protected updateOutputs(): void;
 	metadata(handler: MetadataHandler): void;
@@ -1164,18 +1162,18 @@ export declare class FaustCompiler implements IFaustCompiler {
 		code: string;
 		json: any;
 		poly: boolean;
-	}>): Promise<Map<string, FaustDspFactory>[]>;
+	}>): Promise<Map<string, Required<LooseFaustDspFactory>>[]>;
 	/**
 	 * Import a stringified DSP factories table
 	 */
-	static importDSPFactories(tableStr: string): Promise<Map<string, FaustDspFactory>[]>;
+	static importDSPFactories(tableStr: string): Promise<Map<string, Required<LooseFaustDspFactory>>[]>;
 	constructor(libFaust: ILibFaust);
 	private intVec2intArray;
 	private createDSPFactory;
 	version(): string;
 	getErrorMessage(): string;
-	createMonoDSPFactory(name: string, code: string, args: string): Promise<FaustDspFactory | null>;
-	createPolyDSPFactory(name: string, code: string, args: string): Promise<FaustDspFactory | null>;
+	createMonoDSPFactory(name: string, code: string, args: string): Promise<Required<LooseFaustDspFactory> | null>;
+	createPolyDSPFactory(name: string, code: string, args: string): Promise<Required<LooseFaustDspFactory> | null>;
 	deleteDSPFactory(factory: FaustDspFactory): void;
 	expandDSP(code: string, args: string): string;
 	generateAuxFiles(name: string, code: string, args: string): boolean;
@@ -1524,6 +1522,20 @@ 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.
@@ -1697,6 +1709,16 @@ export declare class FaustPolyDspGenerator implements IFaustPolyDspGenerator {
 	getJSON(): string;
 	getUI(): FaustUIDescriptor;
 }
+export declare class FaustDspGenerator implements IFaustDspGenerator {
+	private static compilerPromise;
+	private extractMidiAndNvoices;
+	/**
+	 * 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.
+	 */
+	createFaustNode(context: BaseAudioContext, name: string, code: string, sp?: boolean, bufferSize?: number): Promise<IFaustMonoWebAudioNode | IFaustPolyWebAudioNode | null>;
+}
 
 export {
 	AudioData$1 as AudioData,