@blibliki/engine 0.3.5 → 0.3.7

package/dist/index.d.cts

@@ -38,7 +38,7 @@ declare class Note implements INote {
 declare enum MidiEventType {
     noteOn = "noteon",
     noteOff = "noteoff",
-    cc = "cc"
+    cc = "controlchange"
 }
 declare class MidiEvent {
     note?: Note;
@@ -50,6 +50,9 @@ declare class MidiEvent {
     constructor(message: Message, triggeredAt: ContextTime);
     get type(): MidiEventType;
     get isNote(): boolean;
+    get isCC(): boolean;
+    get cc(): number | undefined;
+    get ccValue(): number | undefined;
     defineNotes(): void;
     get rawMessage(): Message;
     clone(voiceNo?: number): MidiEvent;
@@ -170,6 +173,7 @@ declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T
     protected superInitialized: boolean;
     private _voices;
     private _name;
+    private pendingUIUpdates;
     constructor(engineId: string, params: IPolyModuleConstructor<T>);
     get name(): string;
     set name(value: string);
@@ -189,6 +193,8 @@ declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T
     protected unPlugAll(): void;
     dispose(): void;
     onMidiEvent: (midiEvent: MidiEvent) => void;
+    triggerPropsUpdate: () => void;
+    private sheduleTriggerUpdate;
     findVoice(voiceNo: number): Module<T>;
     protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
     protected registerAudioInput(props: Omit<PolyAudioInputProps, "ioType">): PolyAudioInput;
@@ -268,6 +274,46 @@ type IModuleSerialize<T extends ModuleType> = IModule<T> & {
 type IModuleConstructor<T extends ModuleType> = Optional<IModule<T>, "id" | "voiceNo"> & {
     audioNodeConstructor?: (context: Context) => AudioNode;
 };
+/**
+ * Helper type for type-safe property lifecycle hooks.
+ *
+ * Hooks are completely optional - only define the ones you need.
+ * Use explicit type annotation for automatic type inference.
+ *
+ * @example
+ * ```typescript
+ * export type IGainProps = {
+ *   gain: number;
+ *   muted: boolean;
+ * };
+ *
+ * export class MonoGain extends Module<ModuleType.Gain> {
+ *   // ✅ Define only the hooks you need with type annotation
+ *   // value type is automatically inferred as number!
+ *   onSetGain: SetterHooks<IGainProps>["onSetGain"] = (value) => {
+ *     this.audioNode.gain.value = value;
+ *     return value; // optional: return modified value
+ *   };
+ *
+ *   // ✅ onAfterSet is called after prop is set
+ *   onAfterSetMuted: SetterHooks<IGainProps>["onAfterSetMuted"] = (value) => {
+ *     if (value) this.audioNode.gain.value = 0;
+ *   };
+ *
+ *   // ✅ You can omit hooks you don't need - they're optional!
+ *   // No need to define onSetMuted if you don't need it
+ *
+ *   // ❌ This would cause a type error:
+ *   // onSetGain: SetterHooks<IGainProps>["onSetGain"] = (value: string) => value;
+ *   //                                                            ^^^^^^ Error!
+ * }
+ * ```
+ */
+type SetterHooks<P> = {
+    [K in keyof P as `onSet${Capitalize<string & K>}`]: (value: P[K]) => P[K];
+} & {
+    [K in keyof P as `onAfterSet${Capitalize<string & K>}`]: (value: P[K]) => void;
+};
 declare abstract class Module<T extends ModuleType> implements IModule<T> {
     id: string;
     engineId: string;
@@ -280,9 +326,11 @@ declare abstract class Module<T extends ModuleType> implements IModule<T> {
     protected _props: ModuleTypeToPropsMapping[T];
     protected superInitialized: boolean;
     protected activeNotes: Note[];
+    private pendingUIUpdates;
     constructor(engineId: string, params: IModuleConstructor<T>);
     get props(): ModuleTypeToPropsMapping[T];
     set props(value: Partial<ModuleTypeToPropsMapping[T]>);
+    private callPropHook;
     serialize(): IModuleSerialize<T>;
     plug({ audioModule, from, to, }: {
         audioModule: AnyModule;
@@ -295,8 +343,10 @@ declare abstract class Module<T extends ModuleType> implements IModule<T> {
     stop(_time: ContextTime): void;
     triggerAttack(note: Note, _triggeredAt: ContextTime): void;
     triggerRelease(note: Note, _triggeredAt: ContextTime): void;
+    handleCC(_event: MidiEvent, _triggeredAt: ContextTime): void;
     onMidiEvent: (midiEvent: MidiEvent) => void;
-    protected triggerPropsUpdate(): void;
+    triggerPropsUpdate: () => void;
+    private sheduleTriggerUpdate;
     dispose(): void;
     protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
     protected registerAudioInput(props: Omit<AudioInputProps, "ioType">): AudioInput;
@@ -353,6 +403,7 @@ type NumberProp = BasePropType & {
     min?: number;
     max?: number;
     step?: number;
+    exp?: number;
 };
 type EnumProp<T extends string | number> = BasePropType & {
     kind: "enum";
@@ -368,11 +419,70 @@ type BooleanProp = BasePropType & {
 type ArrayProp = BasePropType & {
     kind: "array";
 };
-type PropDefinition<T> = T extends number ? NumberProp | EnumProp<number> : T extends boolean ? BooleanProp : T extends string ? StringProp | EnumProp<string> : T extends (string | number)[] ? ArrayProp : never;
-type PropSchema<T> = {
-    [K in keyof T]: PropDefinition<T[K]>;
+type PropSchema = NumberProp | EnumProp<string> | EnumProp<number> | StringProp | BooleanProp | ArrayProp;
+type PrimarySchemaForType<T> = T extends boolean ? BooleanProp : T extends string ? StringProp : T extends number ? NumberProp : T extends unknown[] ? ArrayProp : never;
+/**
+ * Schema type that maps each property to its primary schema type, with optional overrides.
+ * This provides excellent IntelliSense for both simple and complex cases.
+ *
+ * Basic usage:
+ * ```typescript
+ * type MyProps = { count: number; name: string; enabled: boolean };
+ * const mySchema: ModulePropSchema<MyProps> = {
+ *   count: { kind: "number", min: 0, max: 100 },
+ *   name: { kind: "string" },
+ *   enabled: { kind: "boolean" }
+ * };
+ * ```
+ *
+ * With overrides for custom schema types:
+ * ```typescript
+ * type MyProps = { wave: OscillatorWave; frequency: number };
+ * const mySchema: ModulePropSchema<MyProps, {
+ *   wave: EnumProp<OscillatorWave>
+ * }> = {
+ *   wave: { kind: "enum", options: Object.values(OscillatorWave) },
+ *   frequency: { kind: "number", min: 0, max: 1000 }
+ * };
+ * ```
+ */
+type ModulePropSchema<T, TOverrides extends Partial<Record<keyof T, PropSchema>> = EmptyObject> = {
+    [K in keyof T]: K extends keyof TOverrides ? TOverrides[K] : PrimarySchemaForType<T[K]>;
 };
 
+type IOscillator = IModule<ModuleType.Oscillator>;
+declare enum OscillatorWave {
+    sine = "sine",
+    triangle = "triangle",
+    square = "square",
+    sawtooth = "sawtooth"
+}
+/**
+ * Props for the Oscillator module.
+ *
+ * @property wave - Waveform shape of the oscillator.
+ *                  One of: "sine", "square", "sawtooth", "triangle", or "custom".
+ * @property frequency - Base frequency in Hz (e.g. 440 for A4).
+ * @property fine - Fine tuning factor in the range [-1, 1], where ±1 represents ±1 semitone.
+ * @property coarse - Coarse tuning factor in the range [-1, 1], scaled to ±12 semitones.
+ * @property octave - Octave transposition value (e.g. +1 for one octave up, -2 for two octaves down).
+ * @property lowGain - Whether to gain reduction (-18dB). When false, oscillator runs at full gain.
+ */
+type IOscillatorProps = {
+    wave: OscillatorWave;
+    frequency: number;
+    fine: number;
+    coarse: number;
+    octave: number;
+    lowGain: boolean;
+};
+declare class Oscillator extends PolyModule<ModuleType.Oscillator> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Oscillator>);
+    start(time: ContextTime): void;
+    stop(time: ContextTime): void;
+    private registerInputs;
+}
+
 type IVoiceSchedulerProps = EmptyObject;
 declare class Voice extends Module<ModuleType.VoiceScheduler> {
     audioNode: undefined;
@@ -391,25 +501,14 @@ declare class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler> {
     private registerOutputs;
 }
 
-type IBiquadFilterProps = {
-    cutoff: number;
-    envelopeAmount: number;
-    type: BiquadFilterType;
-    Q: number;
-};
-declare class BiquadFilter extends PolyModule<ModuleType.BiquadFilter> {
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.BiquadFilter>);
-    private registerInputs;
-}
-
 type IConstantProps = {
     value: number;
 };
-declare class Constant extends Module<ModuleType.Constant> {
+declare class Constant extends Module<ModuleType.Constant> implements Pick<SetterHooks<IConstantProps>, "onAfterSetValue"> {
     audioNode: ConstantSourceNode;
     isStated: boolean;
     constructor(engineId: string, params: ICreateModule<ModuleType.Constant>);
-    protected onSetValue(value: IConstantProps["value"]): void;
+    onAfterSetValue: SetterHooks<IConstantProps>["onAfterSetValue"];
     start(time: ContextTime): void;
     stop(time: ContextTime): void;
     triggerAttack: (note: Note, triggeredAt: ContextTime) => void;
@@ -429,7 +528,8 @@ declare class Envelope extends PolyModule<ModuleType.Envelope> {
 type IFilterProps = {
     cutoff: number;
     envelopeAmount: number;
-    resonance: number;
+    type: BiquadFilterType;
+    Q: number;
 };
 declare class Filter extends PolyModule<ModuleType.Filter> {
     constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Filter>);
@@ -448,11 +548,11 @@ declare class Gain extends PolyModule<ModuleType.Gain> {
 type IInspectorProps = {
     fftSize: number;
 };
-declare class Inspector extends Module<ModuleType.Inspector> {
+declare class Inspector extends Module<ModuleType.Inspector> implements Pick<SetterHooks<IInspectorProps>, "onAfterSetFftSize"> {
     audioNode: AnalyserNode;
     private _buffer?;
     constructor(engineId: string, params: ICreateModule<ModuleType.Inspector>);
-    protected onSetFftSize(value: number): void;
+    onAfterSetFftSize: SetterHooks<IInspectorProps>["onAfterSetFftSize"];
     get buffer(): Float32Array<ArrayBuffer>;
     getValue(): number;
     getValues(): Float32Array;
@@ -465,68 +565,73 @@ declare class Master extends Module<ModuleType.Master> {
     constructor(engineId: string, params: ICreateModule<ModuleType.Master>);
 }
 
+type IMidiMapper = IModule<ModuleType.MidiMapper>;
+type IMidiMapperProps = {
+    pages: MidiMappingPage[];
+    activePage: number;
+    globalMappings: MidiMapping<ModuleType>[];
+};
+type MidiMappingPage = {
+    name?: string;
+    mappings: MidiMapping<ModuleType>[];
+};
+declare enum MidiMappingMode {
+    direct = "direct",
+    directRev = "directRev",
+    toggleInc = "toggleInc",
+    toggleDec = "toggleDec",
+    incDec = "incDec",
+    incDecRev = "incDecRev"
+}
+type MidiMapping<T extends ModuleType> = {
+    cc?: number;
+    moduleId?: string;
+    moduleType?: T;
+    propName?: string;
+    autoAssign?: boolean;
+    mode?: MidiMappingMode;
+    threshold?: number;
+    step?: number;
+};
+type MidiMapperSetterHooks = Pick<SetterHooks<IMidiMapperProps>, "onSetActivePage">;
+declare class MidiMapper extends Module<ModuleType.MidiMapper> implements MidiMapperSetterHooks {
+    audioNode: undefined;
+    constructor(engineId: string, params: ICreateModule<ModuleType.MidiMapper>);
+    onSetActivePage: MidiMapperSetterHooks["onSetActivePage"];
+    handleCC: (event: MidiEvent, triggeredAt: ContextTime) => void;
+    forwardMapping: (event: MidiEvent, mapping: MidiMapping<ModuleType>, _triggeredAt: ContextTime) => void;
+    private checkAutoAssign;
+}
+
 type IMidiSelectorProps = {
     selectedId: string | undefined | null;
 };
-declare class MidiSelector extends Module<ModuleType.MidiSelector> {
+declare class MidiSelector extends Module<ModuleType.MidiSelector> implements Pick<SetterHooks<IMidiSelectorProps>, "onSetSelectedId"> {
     audioNode: undefined;
     midiOutput: MidiOutput;
     _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
     constructor(engineId: string, params: ICreateModule<ModuleType.MidiSelector>);
-    protected onSetSelectedId(value: string | null): void;
+    onSetSelectedId: SetterHooks<IMidiSelectorProps>["onSetSelectedId"];
     private get forwardMidiEvent();
     private addEventListener;
     private removeEventListener;
     private registerOutputs;
 }
 
-type IOscillator = IModule<ModuleType.Oscillator>;
-declare enum OscillatorWave {
-    sine = "sine",
-    triangle = "triangle",
-    square = "square",
-    sawtooth = "sawtooth"
-}
-/**
- * Props for the Oscillator module.
- *
- * @property wave - Waveform shape of the oscillator.
- *                  One of: "sine", "square", "sawtooth", "triangle", or "custom".
- * @property frequency - Base frequency in Hz (e.g. 440 for A4).
- * @property fine - Fine tuning factor in the range [-1, 1], where ±1 represents ±1 semitone.
- * @property coarse - Coarse tuning factor in the range [-1, 1], scaled to ±12 semitones.
- * @property octave - Octave transposition value (e.g. +1 for one octave up, -2 for two octaves down).
- * @property lowGain - Whether to gain reduction (-18dB). When false, oscillator runs at full gain.
- */
-type IOscillatorProps = {
-    wave: OscillatorWave;
-    frequency: number;
-    fine: number;
-    coarse: number;
-    octave: number;
-    lowGain: boolean;
-};
-declare class Oscillator extends PolyModule<ModuleType.Oscillator> {
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Oscillator>);
-    start(time: ContextTime): void;
-    stop(time: ContextTime): void;
-    private registerInputs;
-}
-
 type IScaleProps = {
     min: number;
     max: number;
     current: number;
 };
-declare class Scale extends Module<ModuleType.Scale> {
+declare class Scale extends Module<ModuleType.Scale> implements Pick<SetterHooks<IScaleProps>, "onAfterSetMin" | "onAfterSetMax" | "onAfterSetCurrent"> {
     audioNode: AudioWorkletNode;
     constructor(engineId: string, params: ICreateModule<ModuleType.Scale>);
     get current(): AudioParam;
     get min(): AudioParam;
     get max(): AudioParam;
-    protected onSetMin(value: number): void;
-    protected onSetMax(value: number): void;
-    protected onSetCurrent(value: number): void;
+    onAfterSetMin: SetterHooks<IScaleProps>["onAfterSetMin"];
+    onAfterSetMax: SetterHooks<IScaleProps>["onAfterSetMax"];
+    onAfterSetCurrent: SetterHooks<IScaleProps>["onAfterSetCurrent"];
 }
 
 type IStepSequencer = IModule<ModuleType.StepSequencer>;
@@ -546,6 +651,14 @@ declare class StepSequencer extends Module<ModuleType.StepSequencer> {
     constructor(engineId: string, params: ICreateModule<ModuleType.StepSequencer>);
 }
 
+type IStereoPannerProps = {
+    pan: number;
+};
+declare class StereoPanner extends PolyModule<ModuleType.StereoPanner> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.StereoPanner>);
+    private registerAdditionalInputs;
+}
+
 type IVirtualMidiProps = {
     activeNotes: string[];
 };
@@ -567,10 +680,11 @@ declare enum ModuleType {
     MidiSelector = "MidiSelector",
     Envelope = "Envelope",
     Filter = "Filter",
-    BiquadFilter = "BiquadFilter",
     Scale = "Scale",
+    StereoPanner = "StereoPanner",
     Inspector = "Inspector",
     Constant = "Constant",
+    MidiMapper = "MidiMapper",
     VirtualMidi = "VirtualMidi",
     StepSequencer = "StepSequencer",
     VoiceScheduler = "VoiceScheduler"
@@ -582,10 +696,11 @@ type ModuleTypeToPropsMapping = {
     [ModuleType.MidiSelector]: IMidiSelectorProps;
     [ModuleType.Envelope]: IEnvelopeProps;
     [ModuleType.Filter]: IFilterProps;
-    [ModuleType.BiquadFilter]: IBiquadFilterProps;
     [ModuleType.Scale]: IScaleProps;
+    [ModuleType.StereoPanner]: IStereoPannerProps;
     [ModuleType.Inspector]: IInspectorProps;
     [ModuleType.Constant]: IConstantProps;
+    [ModuleType.MidiMapper]: IMidiMapperProps;
     [ModuleType.VirtualMidi]: IVirtualMidiProps;
     [ModuleType.StepSequencer]: IStepSequencerProps;
     [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
@@ -597,16 +712,36 @@ type ModuleTypeToModuleMapping = {
     [ModuleType.MidiSelector]: MidiSelector;
     [ModuleType.Envelope]: Envelope;
     [ModuleType.Filter]: Filter;
-    [ModuleType.BiquadFilter]: BiquadFilter;
     [ModuleType.Scale]: Scale;
+    [ModuleType.StereoPanner]: StereoPanner;
     [ModuleType.Inspector]: Inspector;
     [ModuleType.Constant]: Constant;
+    [ModuleType.MidiMapper]: MidiMapper;
     [ModuleType.VirtualMidi]: VirtualMidi;
     [ModuleType.StepSequencer]: StepSequencer;
     [ModuleType.VoiceScheduler]: VoiceScheduler;
 };
 declare const moduleSchemas: {
-    [K in ModuleType]: PropSchema<Partial<ModuleTypeToPropsMapping[K]>>;
+    Oscillator: ModulePropSchema<IOscillatorProps, {
+        wave: EnumProp<OscillatorWave>;
+    }>;
+    Gain: ModulePropSchema<IGainProps, _blibliki_utils.EmptyObject>;
+    Master: ModulePropSchema<_blibliki_utils.EmptyObject, _blibliki_utils.EmptyObject>;
+    MidiSelector: ModulePropSchema<IMidiSelectorProps, _blibliki_utils.EmptyObject>;
+    Envelope: ModulePropSchema<IEnvelopeProps, _blibliki_utils.EmptyObject>;
+    Filter: ModulePropSchema<IFilterProps, {
+        type: EnumProp<BiquadFilterType>;
+    }>;
+    Scale: ModulePropSchema<IScaleProps, _blibliki_utils.EmptyObject>;
+    StereoPanner: ModulePropSchema<IStereoPannerProps, _blibliki_utils.EmptyObject>;
+    Inspector: ModulePropSchema<IInspectorProps, {
+        fftSize: EnumProp<number>;
+    }>;
+    Constant: ModulePropSchema<IConstantProps, _blibliki_utils.EmptyObject>;
+    MidiMapper: ModulePropSchema<IMidiMapperProps, _blibliki_utils.EmptyObject>;
+    VirtualMidi: ModulePropSchema<IVirtualMidiProps, _blibliki_utils.EmptyObject>;
+    StepSequencer: ModulePropSchema<Omit<IStepSequencerProps, "sequences">, _blibliki_utils.EmptyObject>;
+    VoiceScheduler: ModulePropSchema<_blibliki_utils.EmptyObject, _blibliki_utils.EmptyObject>;
 };
 
 type AnyModule = Module<ModuleType>;
@@ -617,7 +752,7 @@ type ICreateModule<T extends ModuleType> = {
     props: Partial<ModuleTypeToPropsMapping[T]>;
 };
 type ModuleParams = {
-    [K in ModuleType]: K extends ModuleType.Oscillator | ModuleType.Gain | ModuleType.Envelope | ModuleType.Filter | ModuleType.BiquadFilter | ModuleType.VoiceScheduler ? IPolyModuleConstructor<K> : ICreateModule<K>;
+    [K in ModuleType]: K extends ModuleType.Oscillator | ModuleType.Gain | ModuleType.Envelope | ModuleType.Filter | ModuleType.StereoPanner | ModuleType.VoiceScheduler ? IPolyModuleConstructor<K> : ICreateModule<K>;
 }[ModuleType];
 
 type IOProps = {
@@ -685,8 +820,8 @@ declare class Engine {
     constructor(context: Context);
     get state(): _blibliki_transport.TransportState;
     initialize(): Promise<void>;
-    addModule<T extends ModuleType>(params: ICreateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.BiquadFilter> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
-    updateModule<T extends ModuleType>(params: IUpdateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.BiquadFilter> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
+    addModule<T extends ModuleType>(params: ICreateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.StereoPanner> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.MidiMapper> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
+    updateModule<T extends ModuleType>(params: IUpdateModule<T>): IModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.StereoPanner> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiSelector> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.MidiMapper> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer>;
     removeModule(id: string): void;
     addRoute(props: ICreateRoute): IRoute;
     removeRoute(id: string): void;
@@ -703,11 +838,11 @@ declare class Engine {
     findModule(id: string): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping];
     findIO(moduleId: string, ioName: string, type: "input" | "output"): Base;
     findMidiDevice(id: string): MidiDevice | ComputerKeyboardInput | undefined;
-    onPropsUpdate(callback: <T extends ModuleType>(params: IModule<T>) => void): void;
-    _triggerPropsUpdate<T extends ModuleType>(params: IModule<T>): void;
+    onPropsUpdate(callback: <T extends ModuleType>(params: IModule<T> | IPolyModule<T>) => void): void;
+    _triggerPropsUpdate<T extends ModuleType>(params: IModule<T> | IPolyModule<T>): void;
     triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
     private onStart;
     private onStop;
 }
 
-export { type ArrayProp, type BooleanProp, Engine, type EnumProp, type ICreateModule, type ICreateRoute, type IGain, type IIOSerialize, type IMaster, type IMidiDevice, type IModule, type IModuleSerialize, type INote, type IOscillator, type IPolyModuleSerialize, type IRoute, type ISequence, type IStepSequencer, type IStepSequencerProps, type IUpdateModule, MidiDevice, MidiPortState, type ModuleParams, ModuleType, type ModuleTypeToPropsMapping, Note, type NumberProp, OscillatorWave, type PropDefinition, type PropSchema, type StringProp, moduleSchemas };
+export { type ArrayProp, type BooleanProp, Engine, type EnumProp, type ICreateModule, type ICreateRoute, type IGain, type IIOSerialize, type IMaster, type IMidiDevice, type IMidiMapper, type IMidiMapperProps, type IModule, type IModuleSerialize, type INote, type IOscillator, type IPolyModuleSerialize, type IRoute, type ISequence, type IStepSequencer, type IStepSequencerProps, type IUpdateModule, MidiDevice, type MidiMapping, MidiMappingMode, MidiPortState, type ModuleParams, type ModulePropSchema, ModuleType, type ModuleTypeToPropsMapping, Note, type NumberProp, OscillatorWave, type PropSchema, type StringProp, moduleSchemas };