@fluex/fluexgl-dsp 0.4.1 → 0.4.2

package/lib/src/effects/classes/Analyser.ts

@@ -0,0 +1,84 @@
+import { Effector } from "../../core/exports";
+
+type AnalyserOptionKeys = keyof Omit<AnalyserOptions, "channelCount" | "channelCountMode" | "channelInterpretation">;
+
+export class Analyser extends Effector {
+
+    public label: string | null = "Analyser";
+    public name: string = "Analyser";
+
+    public analyserNode: AnalyserNode | null = null;
+
+    public float32ArrayBuffer = new Float32Array();
+    public uint8ArrayBuffer = new Uint8Array();
+
+    private options: AnalyserOptions = {
+        fftSize: 32,
+        smoothingTimeConstant: 0.8,
+        minDecibels: -90,
+        maxDecibels: -10,
+    };
+
+    constructor(options?: Partial<AnalyserOptions>) {
+        super();
+
+        if (options) this.SetOptions(options);
+    }
+
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+
+        this.context = context;
+        this.analyserNode = new AnalyserNode(context, this.options);
+
+        this.audioWorkletNode = this.analyserNode as unknown as AudioWorkletNode;
+        this.allocateBuffers();
+    }
+
+    public SetOptions(options: Partial<AnalyserOptions>): void {
+
+        (Object.keys(options) as AnalyserOptionKeys[]).forEach((key) => {
+            const value = options[key];
+
+            if (typeof value === "undefined") return;
+
+            if (key === "fftSize" && value) {
+                const allowed = [32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+                if (!allowed.includes(value)) return;
+            }
+
+            (this.options as any)[key] = value;
+
+            if (this.analyserNode) {
+                (this.analyserNode as any)[key] = value;
+            }
+        });
+
+        if (options.fftSize && this.analyserNode) {
+            this.allocateBuffers();
+        }
+    }
+
+    public GetWaveformFloatData(): Float32Array | null {
+
+        if (!this.analyserNode) return null;
+
+        this.analyserNode.getFloatTimeDomainData(this.float32ArrayBuffer);
+        return this.float32ArrayBuffer;
+    }
+
+    public GetWaveformByteData(): Uint8Array | null {
+
+        if (!this.analyserNode) return null;
+
+        this.analyserNode.getByteTimeDomainData(this.uint8ArrayBuffer);
+        return this.uint8ArrayBuffer;
+    }
+
+    private allocateBuffers(): void {
+
+        if (!this.analyserNode) return;
+
+        this.float32ArrayBuffer = new Float32Array(this.analyserNode.fftSize);
+        this.uint8ArrayBuffer = new Uint8Array(this.analyserNode.fftSize);
+    }
+}

package/lib/src/effects/classes/Chorus.ts

@@ -1,6 +1,6 @@
-import { SendMessageToWorklet, CreateAudioWorkletNode } from "../../utilities/helpers";
+import { CoerceFiniteNumber, SendMessageToWorklet, CreateAudioWorkletNode } from "../../utilities/helpers";
 import { Effector } from "../../core/classes/Effector";
-import { ChorusEffectOptions, ChorusMessageCommandId, AudioWorkletProcessorNames } from "../../typings";
+import { ChorusEffectOptions, ChorusMessageCommandId, AudioWorkletProcessorNames, StrictMode } from "../../typings";
 
 export class Chorus extends Effector {
 
@@ -12,21 +12,24 @@ export class Chorus extends Effector {
     public rateHz: number = 1.5;
     public mix: number = 0.5;
     public feedback: number = 0.2;
+    public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ baseDelayMs, depthMs, rateHz, mix, feedback }: Partial<ChorusEffectOptions>) {
+    constructor({ baseDelayMs, depthMs, rateHz, mix, feedback, strictMode }: Partial<ChorusEffectOptions>) {
         super();
 
-        this.baseDelayMs = baseDelayMs ?? this.baseDelayMs;
-        this.depthMs = depthMs ?? this.depthMs;
-        this.rateHz = rateHz ?? this.rateHz;
-        this.mix = mix ?? this.mix;
-        this.feedback = feedback ?? this.feedback;
-    }
+        this.baseDelayMs = Math.max(0, CoerceFiniteNumber(baseDelayMs, this.baseDelayMs));
+        this.depthMs = Math.max(0, CoerceFiniteNumber(depthMs, this.depthMs));
+        this.rateHz = Math.max(0, CoerceFiniteNumber(rateHz, this.rateHz));
+        this.mix = Math.max(0, Math.min(1, CoerceFiniteNumber(mix, this.mix)));
+        this.feedback = Math.max(0, Math.min(1, CoerceFiniteNumber(feedback, this.feedback)));
 
-    public async InitializeOnAttachment(parentialContext: AudioContext): Promise<void> {
+        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
+    }
 
-        this.parentialContext = parentialContext;
-        this.audioWorkletNode = CreateAudioWorkletNode<ChorusEffectOptions>(parentialContext, AudioWorkletProcessorNames.Chorus, this.ReturnOptionsAsObject());
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+        this.context = context;
+        this.audioWorkletNode = CreateAudioWorkletNode<ChorusEffectOptions>(context, AudioWorkletProcessorNames.Chorus, this.ReturnOptionsAsObject());
     }
 
     public ReturnOptionsAsObject(): ChorusEffectOptions {
@@ -36,31 +39,37 @@ export class Chorus extends Effector {
             rateHz: this.rateHz,
             mix: this.mix,
             feedback: this.feedback,
+            strictMode: this.strictMode
         }
     }
 
     public SetBaseDelayMs(value: number): boolean {
+        value = Math.max(0, CoerceFiniteNumber(value, this.baseDelayMs));
         this.baseDelayMs = value;
         return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetBaseDelayMs, value);
     }
 
     public SetDepthMs(value: number) {
+        value = Math.max(0, CoerceFiniteNumber(value, this.depthMs));
         this.depthMs = value;
         return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetDepthMs, value);
     }
 
     public SetRateHz(value: number) {
+        value = Math.max(0, CoerceFiniteNumber(value, this.rateHz));
         this.rateHz = value;
         return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetRateHz, value);
     }
 
     public SetMix(value: number) {
+        value = Math.max(0, Math.min(1, CoerceFiniteNumber(value, this.mix)));
         this.mix = value;
         return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetMix, value);
     }
 
     public SetFeedback(value: number) {
+        value = Math.max(0, Math.min(1, CoerceFiniteNumber(value, this.feedback)));
         this.feedback = value;
         return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetFeedback, value);
     }
-}
+}

package/lib/src/effects/classes/clips/HardClip.ts

@@ -1,6 +1,6 @@
 import { Effector } from "../../../core/classes/Effector";
-import { CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
-import { HardClipMessageCommandId, AudioWorkletProcessorNames, HardClipOptions } from "../../../typings";
+import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { HardClipMessageCommandId, AudioWorkletProcessorNames, HardClipOptions, StrictMode } from "../../../typings";
 
 export class HardClip extends Effector {
 
@@ -9,33 +9,40 @@ export class HardClip extends Effector {
 
     public drive: number = 1;
     public gain: number = 1;
+    public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ drive, gain }: Partial<HardClipOptions>) {
+    constructor({ drive, gain, strictMode }: Partial<HardClipOptions>) {
         super();
 
-        this.drive = drive ?? this.drive;
-        this.gain = gain ?? this.gain;
+        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+
+        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(parentialContext: AudioContext): Promise<void> {
-        this.parentialContext = parentialContext;
-        this.audioWorkletNode = CreateAudioWorkletNode<HardClipOptions>(parentialContext, AudioWorkletProcessorNames.HardClip, this.ReturnOptionsAsObject());
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+        this.context = context;
+        this.audioWorkletNode = CreateAudioWorkletNode<HardClipOptions>(context, AudioWorkletProcessorNames.HardClip, this.ReturnOptionsAsObject());
     }
 
     public ReturnOptionsAsObject(): HardClipOptions {
         return {
             drive: this.drive,
-            gain: this.gain
+            gain: this.gain,
+            strictMode: this.strictMode
         }
     }
 
      public SetDrive(drive: number): boolean {
+        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
         this.drive = drive;
         return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetDrive, drive);
     }
 
     public SetGain(gain: number): boolean{
+        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
         this.gain = gain;
         return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetGain, gain);
     }
-}
+}

package/lib/src/effects/classes/clips/SoftClip.ts

@@ -1,6 +1,6 @@
-import { CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
 import { Effector } from "../../../core/classes/Effector";
-import { SoftClipOptions, AudioWorkletProcessorNames, SoftClipMessageCommandId } from "../../../typings";
+import { SoftClipOptions, AudioWorkletProcessorNames, SoftClipMessageCommandId, StrictMode } from "../../../typings";
 
 export class SoftClip extends Effector {
 
@@ -9,33 +9,40 @@ export class SoftClip extends Effector {
 
     public drive: number = 1;
     public gain: number = 1;
+    public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ drive, gain }: Partial<SoftClipOptions>) {
+    constructor({ drive, gain, strictMode }: Partial<SoftClipOptions>) {
         super();
 
-        this.drive = drive ?? this.drive;
-        this.gain = gain ?? this.gain;
+        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+
+        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(parentialContext: AudioContext): Promise<void> {
-        this.parentialContext = parentialContext;
-        this.audioWorkletNode = CreateAudioWorkletNode<SoftClipOptions>(parentialContext, AudioWorkletProcessorNames.SoftClip, this.ReturnOptionsAsObject());
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+        this.context = context;
+        this.audioWorkletNode = CreateAudioWorkletNode<SoftClipOptions>(context, AudioWorkletProcessorNames.SoftClip, this.ReturnOptionsAsObject());
     }
 
     public ReturnOptionsAsObject(): SoftClipOptions {
         return {
             drive: this.drive,
-            gain: this.gain
+            gain: this.gain,
+            strictMode: this.strictMode
         }
     }
 
     public SetDrive(drive: number): boolean {
+        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
         this.drive = drive;
         return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetDrive, drive);
     }
 
     public SetGain(gain: number): boolean{
+        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
         this.gain = gain;
         return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetGain, gain);
     }
-}
+}

package/lib/src/effects/classes/filters/LowPassFilter.ts

@@ -1,8 +1,8 @@
 import { Effector } from "../../../core/classes/Effector";
 
-import { SendMessageToWorklet, CreateAudioWorkletNode } from "../../../utilities/helpers";
+import { CoerceFiniteNumber, SendMessageToWorklet, CreateAudioWorkletNode } from "../../../utilities/helpers";
 
-import { LowPassFilterOptions, LowPassFilterMessageCommandId, AudioWorkletProcessorNames } from "../../../typings";
+import { LowPassFilterOptions, LowPassFilterMessageCommandId, AudioWorkletProcessorNames, StrictMode } from "../../../typings";
 
 export class LowPassFilter extends Effector {
 
@@ -12,36 +12,44 @@ export class LowPassFilter extends Effector {
     public cutoff: number = 1000;
     public q: number = 0.7;
     public minFrequency: number = 10;
+    public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ cutoff, minFrequency, q }: Partial<LowPassFilterOptions>) {
+    constructor({ cutoff, minFrequency, q, strictMode }: Partial<LowPassFilterOptions>) {
         super();
 
-        this.cutoff = cutoff ?? this.cutoff;
-        this.minFrequency = minFrequency ?? this.minFrequency;
-        this.q = q ?? this.q;
+        this.cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        this.minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
+        this.q = CoerceFiniteNumber(q, this.q);
+
+        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(parentialContext: AudioContext): Promise<void> {
+    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
 
-        this.parentialContext = parentialContext;
-        this.audioWorkletNode = CreateAudioWorkletNode(parentialContext, AudioWorkletProcessorNames.LowPassFilter, this.ReturnOptionsAsObject());
-        this.registerMessageEventListener(this.audioWorkletNode as AudioWorkletNode);
+        this.context = context;
+        this.audioWorkletNode = CreateAudioWorkletNode(context, AudioWorkletProcessorNames.LowPassFilter, this.ReturnOptionsAsObject());
+        this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
     }
 
     public ReturnOptionsAsObject(): LowPassFilterOptions {
         return {
             cutoff: this.cutoff,
             minFrequency: this.minFrequency,
-            q: this.q
+            q: this.q,
+            strictMode: this.strictMode
         }
     }
 
     public SetCutoff(cutoff: number = 1000): boolean {
 
-        if (!this.parentialContext) return false;
+        if (!this.context) return false;
+
+        cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = Math.max(this.minFrequency, cutoff);
 
-        if (cutoff >= this.parentialContext.sampleRate)
-            cutoff = this.parentialContext.sampleRate;
+        if (cutoff >= this.context.sampleRate)
+            cutoff = this.context.sampleRate;
 
         this.cutoff = cutoff;
         return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetCutoff, cutoff);
@@ -49,6 +57,8 @@ export class LowPassFilter extends Effector {
 
     public SetMinFrequency(minFrequency: number = 10): boolean {
 
+        minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
+
         if (minFrequency < 10)
             minFrequency = 10;
 
@@ -58,10 +68,13 @@ export class LowPassFilter extends Effector {
 
     public SetQ(q: number = 0.7): boolean {
 
+        q = CoerceFiniteNumber(q, this.q);
+        q = Math.max(0.0001, q);
+
         if(q > 4) 
             q = 4;
 
         this.q = q;
         return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetQ, q);
     }
-}
+}

package/lib/src/effects/exports.ts

@@ -1,4 +1,5 @@
 export { Chorus } from "./classes/Chorus";
+export { Analyser } from "./classes/Analyser";
 export { Distortion } from "./classes/Distortion";
 export { Equalizer } from "./classes/Equalizer";
 export { Limiter } from "./classes/Limiter";
@@ -21,4 +22,4 @@ export { GenericReverb } from "./classes/reverbs/GenericReverb";
 export { HallReverb } from "./classes/reverbs/HallReverb";
 export { RoomReverb } from "./classes/reverbs/RoomReverb";
 
-export { LowPassFilter } from "./classes/filters/LowPassFilter";
+export { LowPassFilter } from "./classes/filters/LowPassFilter";

package/lib/src/index.ts

@@ -3,30 +3,25 @@
  * A javascript digital audio processor library.
  */
 
-import { FluexGLAudioDescriptor } from "./typings";
+import { DspOptions } from "./typings";
 
-export const FluexGLAudio: FluexGLAudioDescriptor = {
-    name: "FluexGL Audio",
-    author: "Rohan Kanhaisingh",
-    version: "0.0.2",
-    license: "MIT",
-    repository: "https://github.com/rohankanhaisingh/FluexGL-Audio",
-    options: {
-        maxMasterChannels: 8,
-        maxTotalChannels: 128,
-        sampleRate: 44000,
-        spatialization: "stereo",
-        debugger: {
-            showErrors: true,
-            showInfo: true,
-            showWarnings: true,
-            breakOnError: true
-        }
+export const DSP: DspOptions = {
+    maxMasterChannels: 8,
+    maxTotalChannels: 128,
+    sampleRate: 44000,
+    spatialization: "stereo",
+    overrideMaxAudioBufferNodes: false,
+    debugger: {
+        showErrors: true,
+        showInfo: true,
+        showWarnings: true,
+        breakOnError: true
     }
 }
 
 export {
     Chorus,
+    Analyser,
     Distortion,
     Equalizer,
     Limiter,
@@ -78,10 +73,19 @@ export {
     hasInitializedWasm,
 } from "./utilities/web-assembly";
 
+export {
+    StrictMode,
+    ProcessorIdentificationCodes,
+    HardClipMessageCommandId,
+    SoftClipMessageCommandId,
+    AudioWorkletProcessorNames,
+    ChorusMessageCommandId,
+    LowPassFilterMessageCommandId
+} from "./typings";
+
 export type {
-    FluexGLAudioDescriptor,
-    FluexGLAudioDebuggerOptions,
-    FluexGLAudioOptions,
+    DspDebuggerOptions,
+    DspOptions,
     LoadAudioSourceOptions,
     AudioSourceData,
     ChannelOptions,
@@ -95,17 +99,11 @@ export type {
     DspPipelineInitializationState,
     ChorusEffectOptions,
     LowPassFilterOptions,
-    LowPassFilterMessageCommandId,
-    ChorusMessageCommandId,
-    AudioWorkletProcessorNames,
-    SoftClipMessageCommandId,
     SoftClipOptions,
-    HardClipMessageCommandId,
     HardClipOptions,
     EffectorEventMap,
     IncomingMessageType,
     IncomingProcessorMessage,
     ProcessorData,
-    ProcessorIdentificationCodes,
-    EffectorEvents
-} from "./typings";
+    EffectorEvents,
+} from "./typings";

package/lib/src/typings.ts

@@ -60,28 +60,25 @@ export enum ProcessorIdentificationCodes {
     UnknownProcessorCreationDate = "UNKNOWN_PROCESSOR_CREATION_DATE"
 }
 
-export interface FluexGLAudioDebuggerOptions {
+export enum StrictMode {
+    Disabled = 0x00,
+    Enabled = 0x01
+}
+
+export interface DspDebuggerOptions {
     breakOnError: boolean;
     showInfo: boolean;
     showErrors: boolean;
     showWarnings: boolean;
 }
 
-export interface FluexGLAudioOptions {
+export interface DspOptions {
     maxMasterChannels: number;
     maxTotalChannels: number;
     sampleRate: number;
     spatialization: ChannelSpatialization;
-    debugger: FluexGLAudioDebuggerOptions;
-}
-
-export interface FluexGLAudioDescriptor {
-    name: string;
-    author: string;
-    version: string;
-    license: string;
-    repository: string;
-    options: FluexGLAudioOptions;
+    debugger: DspDebuggerOptions;
+    overrideMaxAudioBufferNodes: boolean;
 }
 
 export interface LoadAudioSourceOptions {
@@ -116,6 +113,7 @@ export interface AudioClipEventMap {
 export interface DspPipelineInitializationOptions {
     pathToWasm: string;
     pathToWorklet: string;
+    options?: Partial<DspOptions>;
 }
 
 export interface DspPipelineInitializationState {
@@ -123,30 +121,32 @@ export interface DspPipelineInitializationState {
     workletBlobUrl: string;
 }
 
-// ======== Effect options ========
-
 export interface ChorusEffectOptions {
     baseDelayMs: number;
     depthMs: number;
     rateHz: number;
     mix: number;
     feedback: number;
+    strictMode: StrictMode;
 }
 
 export interface LowPassFilterOptions {
     cutoff: number;
     minFrequency: number;
     q: number;
+    strictMode: StrictMode;
 }
 
 export interface SoftClipOptions {
     drive: number;
     gain: number;
+    strictMode: StrictMode;
 }
 
 export interface HardClipOptions {
     drive: number;
     gain: number;
+    strictMode: StrictMode;
 }
 
 export interface EffectorEventMap {

package/lib/src/utilities/debugger.ts

@@ -1,12 +1,12 @@
 import { ErrorCodes, WarningCodes } from "../console-codes";
 
-import { FluexGLAudio } from "../index";
+import { DSP } from "../index";
 
 export namespace Debug {
 
     export function Log(message: string, additionalDetails?: string[]) {
 
-        if (!FluexGLAudio.options.debugger.showInfo) return;
+        if (!DSP.debugger.showInfo) return;
 
         let outputString: string = `%c[INFO]: %c${message} %c`;
 
@@ -19,7 +19,7 @@ export namespace Debug {
 
     export function Success(message: string, additionalDetails?: string[]) {
 
-        if (!FluexGLAudio.options.debugger.showInfo) return;
+        if (!DSP.debugger.showInfo) return;
 
         let outputString: string = `%c[SUCCESS]: %c${message} %c`;
 
@@ -32,7 +32,7 @@ export namespace Debug {
 
     export function Warn(message: string, additionalDetails?: string[], warningCode?: WarningCodes) {
 
-        if (!FluexGLAudio.options.debugger.showWarnings) return;
+        if (!DSP.debugger.showWarnings) return;
 
         let outputString: string = `%c(${warningCode ? warningCode : "Unknown".toUpperCase()}) %c[WARNING]: %c${message} %c`;
 
@@ -45,7 +45,7 @@ export namespace Debug {
 
     export function Error(message: string, additionalDetails?: string[], errorCode?: ErrorCodes) {
 
-        if (!FluexGLAudio.options.debugger.showErrors) return;
+        if (!DSP.debugger.showErrors) return;
 
         let outputString: string = `%c(${errorCode ? errorCode : "Unknown".toUpperCase()}) %c[ERROR]: %c${message} %c`;
 
@@ -55,7 +55,7 @@ export namespace Debug {
 
         console.log(outputString, "color: red", "color: red;", "color: white", "color: white; font-style: italic;");
 
-        if (FluexGLAudio.options.debugger.breakOnError) {
+        if (DSP.debugger.breakOnError) {
 
             for (let char of message)
                 outputString = outputString.replace("%c", "");

package/lib/src/utilities/helpers.ts

@@ -235,31 +235,55 @@ export function SendMessageToWorklet<T, K = any>(node: AudioWorkletNode | null,
 
     if (!node) return false;
 
+    if (typeof data === "number" && !Number.isFinite(data)) {
+        Debug.Warn("Refusing to send non-finite numeric value to AudioWorkletNode.", [
+            `Command: ${String(commandId)}`,
+            `Value: ${String(data)}`
+        ]);
+        return false;
+    }
+
     node.port.postMessage({ commandId, data });
 
     return true;
 }
 
+export function IsFiniteNumber(value: unknown): value is number {
+    return typeof value === "number" && Number.isFinite(value);
+}
+
+export function CoerceFiniteNumber(value: unknown, fallback: number): number {
+    return IsFiniteNumber(value) ? value : fallback;
+}
+
 export function CreateAudioWorkletNode<T = any>(context: AudioContext, name: AudioWorkletProcessorNames | string, data: T) {
 
     if (!compiledWebAssemblyModule) {
-        
         Debug.Error("Failed to create audio worklet node, because the web assembly module has not been compiled properly.", [
             `Request audio worklet node: ${name}.`
         ]);
         return null;
     }
 
-    return new AudioWorkletNode(context, name, {
-        numberOfInputs: 1,
-        numberOfOutputs: 1,
-        outputChannelCount: [2],
-        parameterData: {
-            ...data,
-            sampleRate: context.sampleRate
-        },
-        processorOptions: {
-            module: compiledWebAssemblyModule
-        }
-    })
-}
+    try {
+        return new AudioWorkletNode(context, name, {
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [2],
+            parameterData: {
+                ...data,
+                sampleRate: context.sampleRate
+            },
+            processorOptions: {
+                module: compiledWebAssemblyModule
+            }
+        });
+    } catch (err) {
+        Debug.Error("Failed to create audio worklet node.", [
+            `Request audio worklet node: ${name}.`,
+            "Make sure you called InitializeDspPipeline/InitializeDpsPipeline and loaded the worklet module on the same AudioContext.",
+            String(err)
+        ]);
+        return null;
+    }
+}