@blibliki/engine 0.5.2 → 0.9.0

package/dist/index.d.ts

@@ -2,8 +2,57 @@ import * as _blibliki_utils from '@blibliki/utils';
 import { Context, Optional, EmptyObject } from '@blibliki/utils';
 export { Context } from '@blibliki/utils';
 import * as _blibliki_transport from '@blibliki/transport';
-import { Seconds, ContextTime, Transport, TransportEvent, BPM, TimeSignature } from '@blibliki/transport';
-export { Position, TimeSignature, TransportState } from '@blibliki/transport';
+import { Seconds, ContextTime, Division, IPattern, Resolution, PlaybackMode, IStep, Transport, BPM, TimeSignature } from '@blibliki/transport';
+export { BPM, IPage, IPattern, IStep, IStepCC, IStepNote, PlaybackMode, Position, Resolution, TimeSignature, TransportState } from '@blibliki/transport';
+
+/**
+ * Platform-agnostic MIDI interfaces
+ * Allows switching between Web MIDI API and node-midi without refactoring
+ */
+interface IMidiMessageEvent {
+    data: Uint8Array;
+    timeStamp: number;
+}
+type MidiMessageCallback = (event: IMidiMessageEvent) => void;
+interface IMidiInputPort extends IMidiPort {
+    addEventListener(callback: MidiMessageCallback): void;
+    removeEventListener(callback: MidiMessageCallback): void;
+}
+interface IMidiOutputPort extends IMidiPort {
+    send(data: number[] | Uint8Array, timestamp?: number): void;
+}
+interface IMidiPort {
+    readonly id: string;
+    readonly name: string;
+    readonly state: "connected" | "disconnected";
+    readonly type: "input" | "output";
+}
+
+declare enum MidiPortState {
+    connected = "connected",
+    disconnected = "disconnected"
+}
+type IMidiDevice = {
+    id: string;
+    name: string;
+    state: MidiPortState;
+};
+declare abstract class BaseMidiDevice<T extends IMidiPort> implements IMidiDevice {
+    protected midiPort: T;
+    constructor(props: T);
+    abstract connect(): void;
+    abstract disconnect(): void;
+    get id(): string;
+    get name(): string;
+    get type(): "input" | "output";
+    get state(): MidiPortState;
+    serialize(): {
+        id: string;
+        name: string;
+        type: "input" | "output";
+        state: MidiPortState;
+    };
+}
 
 /**
  * Simple wrapper around MIDI message data (Uint8Array)
@@ -74,52 +123,20 @@ declare class MidiEvent {
     clone(voiceNo?: number): MidiEvent;
 }
 
-/**
- * Platform-agnostic MIDI interfaces
- * Allows switching between Web MIDI API and node-midi without refactoring
- */
-interface IMidiMessageEvent {
-    data: Uint8Array;
-    timeStamp: number;
-}
-type MidiMessageCallback = (event: IMidiMessageEvent) => void;
-interface IMidiInputPort {
-    readonly id: string;
-    readonly name: string;
-    readonly state: "connected" | "disconnected";
-    addEventListener(callback: MidiMessageCallback): void;
-    removeEventListener(callback: MidiMessageCallback): void;
-}
-
-declare enum MidiPortState {
-    connected = "connected",
-    disconnected = "disconnected"
-}
-type IMidiDevice = {
+type IMidiInput = {
     id: string;
     name: string;
     state: MidiPortState;
-};
-type IMidiInput = IMidiDevice & {
     eventListerCallbacks: EventListerCallback[];
 };
 type EventListerCallback = (event: MidiEvent) => void;
-declare class MidiDevice implements IMidiDevice {
-    id: string;
-    name: string;
+declare class MidiInputDevice extends BaseMidiDevice<IMidiInputPort> {
     eventListerCallbacks: EventListerCallback[];
     private context;
-    private input;
     private messageHandler;
     constructor(input: IMidiInputPort, context: Context);
-    get state(): MidiPortState;
     connect(): void;
     disconnect(): void;
-    serialize(): {
-        id: string;
-        name: string;
-        state: MidiPortState;
-    };
     addEventListener(callback: EventListerCallback): void;
     removeEventListener(callback: EventListerCallback): void;
     private processEvent;
@@ -207,6 +224,21 @@ declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T
     private _voices;
     private _name;
     private pendingUIUpdates;
+    /**
+     * Factory method for creating modules with proper initialization timing.
+     *
+     * This method ensures hooks are called AFTER the child class constructor completes,
+     * solving the ES6 class field initialization problem where function properties like hooks
+     * aren't available during super() call.
+     *
+     * @example
+     * const gain = Module.create(Gain, engineId, {
+     *   name: "gain",
+     *   moduleType: ModuleType.Gain,
+     *   props: { gain: 0.5 }
+     * });
+     */
+    static create<T extends ModuleType, M extends PolyModule<T>>(ModuleClass: new (engineId: string, params: IPolyModuleConstructor<T>) => M, engineId: string, params: IPolyModuleConstructor<T>): M;
     constructor(engineId: string, params: IPolyModuleConstructor<T>);
     get name(): string;
     set name(value: string);
@@ -232,8 +264,8 @@ declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T
     protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
     protected registerAudioInput(props: Omit<PolyAudioInputProps, "ioType">): PolyAudioInput;
     protected registerAudioOutput(props: Omit<PolyAudioOutputProps, "ioType">): PolyAudioOutput;
-    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput;
-    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput;
+    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput$1;
+    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput$1;
     private adjustNumberOfModules;
     protected get engine(): Engine;
     protected get context(): _blibliki_utils.Context;
@@ -246,12 +278,12 @@ type MidiInputProps = IOProps & {
 type MidiOutputProps = IOProps & {
     ioType: IOType.MidiOutput;
 };
-declare class MidiInput extends IO<MidiOutput> implements MidiInputProps {
+declare class MidiInput$1 extends IO<MidiOutput$1> implements MidiInputProps {
     ioType: IOType.MidiInput;
     onMidiEvent: MidiInputProps["onMidiEvent"];
     constructor(module: Module<ModuleType> | PolyModule<ModuleType>, props: MidiInputProps);
 }
-declare class MidiOutput extends IO<MidiInput> implements MidiOutputProps {
+declare class MidiOutput$1 extends IO<MidiInput$1> implements MidiOutputProps {
     ioType: IOType.MidiOutput;
     onMidiEvent: (event: MidiEvent) => void;
     private get midiConnections();
@@ -289,7 +321,7 @@ declare abstract class Base implements IIO {
     rePlugAll(callback?: () => void): void;
     unPlugAll(): void;
     isAudio(): this is AudioInput | AudioOutput | PolyAudioInput | PolyAudioOutput;
-    isMidi(): this is MidiInput | MidiOutput;
+    isMidi(): this is MidiInput$1 | MidiOutput$1;
     serialize(): IIOSerialize;
 }
 declare abstract class IO<Connection extends Base> extends Base {
@@ -311,8 +343,8 @@ type IIOTypeTOClass = {
     [IOType.AudioOutput]: AudioOutput;
     [IOType.PolyAudioInput]: PolyAudioInput;
     [IOType.PolyAudioOutput]: PolyAudioOutput;
-    [IOType.MidiInput]: MidiInput;
-    [IOType.MidiOutput]: MidiOutput;
+    [IOType.MidiInput]: MidiInput$1;
+    [IOType.MidiOutput]: MidiOutput$1;
 };
 declare abstract class IOCollection<T extends CollectionType> {
     module: Module<ModuleType> | PolyModule<ModuleType>;
@@ -353,6 +385,11 @@ type SetterHooks<P> = {
 } & {
     [K in keyof P as `onAfterSet${Capitalize<string & K>}`]: (value: P[K]) => void;
 };
+type StateSetterHooks<S> = {
+    [K in keyof S as `onSetState${Capitalize<string & K>}`]: (value: S[K]) => S[K];
+} & {
+    [K in keyof S as `onAfterSetState${Capitalize<string & K>}`]: (value: S[K]) => void;
+};
 declare abstract class Module<T extends ModuleType> implements IModule<T> {
     id: string;
     engineId: string;
@@ -363,12 +400,34 @@ declare abstract class Module<T extends ModuleType> implements IModule<T> {
     inputs: InputCollection;
     outputs: OutputCollection;
     protected _props: ModuleTypeToPropsMapping[T];
+    protected _state: ModuleTypeToStateMapping[T];
     protected activeNotes: Note[];
+    protected _propsInitialized: boolean;
     private pendingUIUpdates;
+    /**
+     * Factory method for creating modules with proper initialization timing.
+     *
+     * This method ensures hooks are called AFTER the child class constructor completes,
+     * solving the ES6 class field initialization problem where function properties like hooks
+     * aren't available during super() call.
+     *
+     * @example
+     * const gain = Module.create(MonoGain, engineId, {
+     *   name: "gain",
+     *   moduleType: ModuleType.Gain,
+     *   props: { gain: 0.5 }
+     * });
+     */
+    static create<T extends ModuleType, M extends Module<T>>(ModuleClass: new (engineId: string, params: ICreateModule<T>) => M, engineId: string, params: Omit<IModuleConstructor<T>, "props"> & {
+        props: Partial<IModule<T>["props"]>;
+    }): M;
     constructor(engineId: string, params: IModuleConstructor<T>);
     get props(): ModuleTypeToPropsMapping[T];
     set props(value: Partial<ModuleTypeToPropsMapping[T]>);
     private callPropHook;
+    get state(): ModuleTypeToStateMapping[T];
+    set state(value: Partial<ModuleTypeToStateMapping[T]>);
+    private callStateHook;
     serialize(): IModuleSerialize<T>;
     plug({ audioModule, from, to, }: {
         audioModule: AnyModule;
@@ -389,12 +448,41 @@ declare abstract class Module<T extends ModuleType> implements IModule<T> {
     protected registerDefaultIOs(value?: "both" | "in" | "out"): void;
     protected registerAudioInput(props: Omit<AudioInputProps, "ioType">): AudioInput;
     protected registerAudioOutput(props: Omit<AudioOutputProps, "ioType">): AudioOutput;
-    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput;
-    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput;
+    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput$1;
+    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput$1;
     protected get engine(): Engine;
     protected get context(): Context;
 }
 
+declare enum ReverbType {
+    room = "room",
+    hall = "hall",
+    plate = "plate",
+    spring = "spring",
+    chamber = "chamber",
+    reflections = "reflections"
+}
+type IReverbProps = {
+    mix: number;
+    decayTime: number;
+    preDelay: number;
+    type: ReverbType;
+};
+declare class Reverb extends Module<ModuleType.Reverb> implements Pick<SetterHooks<IReverbProps>, "onAfterSetMix" | "onAfterSetDecayTime" | "onAfterSetPreDelay" | "onAfterSetType"> {
+    audioNode: GainNode;
+    private outputNode;
+    private convolverNode;
+    private preDelayNode;
+    private wetDryMixer;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Reverb>);
+    private registerCustomOutput;
+    onAfterSetMix: (value: number) => void;
+    onAfterSetDecayTime: () => void;
+    onAfterSetPreDelay: (value: number) => void;
+    onAfterSetType: () => void;
+    private regenerateImpulseResponse;
+}
+
 type BasePropType = {
     label?: string;
     description?: string;
@@ -451,6 +539,97 @@ type ModulePropSchema<T, TOverrides extends Partial<Record<keyof T, PropSchema>>
     [K in keyof T]: K extends keyof TOverrides ? TOverrides[K] : PrimarySchemaForType<T[K]>;
 };
 
+type INoise = IModule<ModuleType.Noise>;
+declare enum NoiseType {
+    white = "white",
+    pink = "pink",
+    brown = "brown",
+    blue = "blue"
+}
+/**
+ * Props for the Noise module.
+ *
+ * @property type - Type of noise to generate.
+ *                  One of: "white", "pink", "brown", or "blue".
+ */
+type INoiseProps = {
+    type: NoiseType;
+};
+type NoiseSetterHooks = Pick<SetterHooks<INoiseProps>, "onAfterSetType">;
+/**
+ * Noise generator module supporting white, pink, brown, and blue noise types.
+ */
+declare class Noise extends Module<ModuleType.Noise> implements NoiseSetterHooks {
+    audioNode: AudioBufferSourceNode;
+    isStated: boolean;
+    private noiseBuffers;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Noise>);
+    onAfterSetType: NoiseSetterHooks["onAfterSetType"];
+    start(time: ContextTime): void;
+    stop(time: ContextTime): void;
+}
+
+type ILFO = IModule<ModuleType.LFO>;
+declare enum LFOWaveform {
+    sine = "sine",
+    triangle = "triangle",
+    square = "square",
+    sawtooth = "sawtooth",
+    rampDown = "rampDown",
+    random = "random"
+}
+type ILFOProps = {
+    sync: boolean;
+    frequency: number;
+    division: Division;
+    waveform: LFOWaveform;
+    offset: number;
+    amount: number;
+};
+declare class LFO extends PolyModule<ModuleType.LFO> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.LFO>);
+}
+
+declare enum DelayTimeMode {
+    short = "short",
+    long = "long"
+}
+type IDelayProps = {
+    time: number;
+    timeMode: DelayTimeMode;
+    sync: boolean;
+    division: Division;
+    feedback: number;
+    mix: number;
+    stereo: boolean;
+};
+declare class Delay extends Module<ModuleType.Delay> implements Pick<SetterHooks<IDelayProps>, "onAfterSetTime" | "onAfterSetTimeMode" | "onAfterSetSync" | "onAfterSetDivision" | "onAfterSetFeedback" | "onAfterSetMix" | "onAfterSetStereo"> {
+    audioNode: GainNode;
+    private outputNode;
+    private wetDryMixer;
+    private delayNode;
+    private feedbackGain;
+    private delayLeft;
+    private delayRight;
+    private feedbackLeft;
+    private feedbackRight;
+    private merger;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Delay>);
+    private setupBPMListener;
+    private updateDelayTime;
+    private connectMonoGraph;
+    private switchToStereo;
+    private disconnectAll;
+    private registerCustomOutput;
+    onAfterSetTime: (_value: number) => void;
+    onAfterSetTimeMode: (value: DelayTimeMode) => void;
+    onAfterSetSync: (_value: boolean) => void;
+    onAfterSetDivision: (_value: Division) => void;
+    onAfterSetFeedback: (value: number) => void;
+    onAfterSetMix: (value: number) => void;
+    onAfterSetStereo: (value: boolean) => void;
+}
+
 type IOscillator = IModule<ModuleType.Oscillator>;
 declare enum OscillatorWave {
     sine = "sine",
@@ -489,19 +668,72 @@ declare class Voice extends Module<ModuleType.VoiceScheduler> {
     audioNode: undefined;
     activeNote: string | null;
     triggeredAt: ContextTime;
+    private occupationRanges;
     constructor(engineId: string, params: ICreateModule<ModuleType.VoiceScheduler>);
+    /**
+     * Check if this voice is occupied at a given time
+     */
+    isOccupiedAt(time: ContextTime): boolean;
+    /**
+     * Get the earliest end time of all occupation ranges at or after the given time
+     * Returns Infinity if the voice has infinite occupation
+     */
+    getEarliestEndTimeAfter(time: ContextTime): ContextTime;
+    /**
+     * Clean up past occupation ranges that are no longer needed
+     */
+    private cleanupPastRanges;
+    /**
+     * Clear all occupation ranges
+     * Useful when resetting or stopping playback
+     */
+    clearOccupationRanges(): void;
     midiTriggered: (midiEvent: MidiEvent) => void;
 }
 declare class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler> {
     audioModules: Voice[];
-    midiOutput: MidiOutput;
+    midiOutput: MidiOutput$1;
     constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.VoiceScheduler>);
     onMidiEvent: (midiEvent: MidiEvent) => void;
     private findFreeVoice;
+    /**
+     * Clear all occupation ranges for all voices
+     * Call this when stopping playback or resetting the scheduler
+     */
+    clearAllOccupationRanges(): void;
     private registerInputs;
     private registerOutputs;
 }
 
+type IChorusProps = {
+    rate: number;
+    depth: number;
+    mix: number;
+    feedback: number;
+};
+declare class Chorus extends Module<ModuleType.Chorus> implements Pick<SetterHooks<IChorusProps>, "onAfterSetRate" | "onAfterSetDepth" | "onAfterSetMix" | "onAfterSetFeedback"> {
+    audioNode: GainNode;
+    private outputNode;
+    private feedbackGain;
+    private delayLeft;
+    private delayRight;
+    private lfoLeft;
+    private lfoRight;
+    private depthLeft;
+    private depthRight;
+    private merger;
+    private wetDryMixer;
+    private rateModGain;
+    constructor(engineId: string, params: ICreateModule<ModuleType.Chorus>);
+    private registerAdditionalInputs;
+    private registerCustomOutput;
+    onAfterSetRate: SetterHooks<IChorusProps>["onAfterSetRate"];
+    onAfterSetDepth: SetterHooks<IChorusProps>["onAfterSetDepth"];
+    onAfterSetMix: SetterHooks<IChorusProps>["onAfterSetMix"];
+    onAfterSetFeedback: SetterHooks<IChorusProps>["onAfterSetFeedback"];
+    dispose(): void;
+}
+
 type IConstantProps = {
     value: number;
 };
@@ -513,16 +745,26 @@ declare class Constant extends Module<ModuleType.Constant> implements Pick<Sette
     start(time: ContextTime): void;
     stop(time: ContextTime): void;
     triggerAttack: (note: Note, triggeredAt: ContextTime) => void;
-    triggerRelease: () => void;
+    triggerRelease: (_: Note, triggeredAt: ContextTime) => void;
 }
 
-type IEnvelopeProps = {
+type IDistortionProps = {
+    drive: number;
+    tone: number;
+    mix: number;
+};
+declare class PolyDistortion extends PolyModule<ModuleType.Distortion> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Distortion>);
+}
+
+type ICustomEnvelopeProps = {
     attack: number;
+    attackCurve: number;
     decay: number;
     sustain: number;
     release: number;
 };
-declare class Envelope extends PolyModule<ModuleType.Envelope> {
+declare class CustomEnvelope extends PolyModule<ModuleType.Envelope> {
     constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Envelope>);
 }
 
@@ -559,6 +801,16 @@ declare class Inspector extends Module<ModuleType.Inspector> implements Pick<Set
     getValues(): Float32Array;
 }
 
+type IEnvelopeProps = {
+    attack: number;
+    decay: number;
+    sustain: number;
+    release: number;
+};
+declare class Envelope extends PolyModule<ModuleType.LegacyEnvelope> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.LegacyEnvelope>);
+}
+
 type IMaster = IModule<ModuleType.Master>;
 type IMasterProps = EmptyObject;
 declare class Master extends Module<ModuleType.Master> {
@@ -566,6 +818,22 @@ declare class Master extends Module<ModuleType.Master> {
     constructor(engineId: string, params: ICreateModule<ModuleType.Master>);
 }
 
+type IMidiInputProps = {
+    selectedId: string | undefined | null;
+    selectedName: string | undefined | null;
+};
+declare class MidiInput extends Module<ModuleType.MidiInput> implements Pick<SetterHooks<IMidiInputProps>, "onSetSelectedId"> {
+    audioNode: undefined;
+    midiOutput: MidiOutput$1;
+    _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
+    constructor(engineId: string, params: ICreateModule<ModuleType.MidiInput>);
+    onSetSelectedId: SetterHooks<IMidiInputProps>["onSetSelectedId"];
+    private get forwardMidiEvent();
+    private addEventListener;
+    private removeEventListener;
+    private registerOutputs;
+}
+
 type IMidiMapper = IModule<ModuleType.MidiMapper>;
 type IMidiMapperProps = {
     pages: MidiMappingPage[];
@@ -586,6 +854,7 @@ declare enum MidiMappingMode {
 }
 type MidiMapping<T extends ModuleType> = {
     cc?: number;
+    value?: number;
     moduleId?: string;
     moduleType?: T;
     propName?: string;
@@ -597,6 +866,7 @@ type MidiMapping<T extends ModuleType> = {
 type MidiMapperSetterHooks = Pick<SetterHooks<IMidiMapperProps>, "onSetActivePage">;
 declare class MidiMapper extends Module<ModuleType.MidiMapper> implements MidiMapperSetterHooks {
     audioNode: undefined;
+    private _midiOut;
     constructor(engineId: string, params: ICreateModule<ModuleType.MidiMapper>);
     onSetActivePage: MidiMapperSetterHooks["onSetActivePage"];
     handleCC: (event: MidiEvent, triggeredAt: ContextTime) => void;
@@ -604,53 +874,73 @@ declare class MidiMapper extends Module<ModuleType.MidiMapper> implements MidiMa
     private checkAutoAssign;
 }
 
-type IMidiSelectorProps = {
+type IMidiOutputProps = {
     selectedId: string | undefined | null;
     selectedName: string | undefined | null;
 };
-declare class MidiSelector extends Module<ModuleType.MidiSelector> implements Pick<SetterHooks<IMidiSelectorProps>, "onSetSelectedId"> {
+declare class MidiOutput extends Module<ModuleType.MidiOutput> implements Pick<SetterHooks<IMidiOutputProps>, "onSetSelectedId"> {
     audioNode: undefined;
-    midiOutput: MidiOutput;
-    _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
-    constructor(engineId: string, params: ICreateModule<ModuleType.MidiSelector>);
-    onSetSelectedId: SetterHooks<IMidiSelectorProps>["onSetSelectedId"];
-    private get forwardMidiEvent();
-    private addEventListener;
-    private removeEventListener;
-    private registerOutputs;
+    midiInput: MidiInput$1;
+    private currentDevice?;
+    constructor(engineId: string, params: ICreateModule<ModuleType.MidiOutput>);
+    onSetSelectedId: SetterHooks<IMidiOutputProps>["onSetSelectedId"];
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    private registerInputs;
 }
 
 type IScaleProps = {
     min: number;
     max: number;
     current: number;
+    mode: "exponential" | "linear";
 };
-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;
-    onAfterSetMin: SetterHooks<IScaleProps>["onAfterSetMin"];
-    onAfterSetMax: SetterHooks<IScaleProps>["onAfterSetMax"];
-    onAfterSetCurrent: SetterHooks<IScaleProps>["onAfterSetCurrent"];
+declare class Scale extends PolyModule<ModuleType.Scale> {
+    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Scale>);
 }
 
 type IStepSequencer = IModule<ModuleType.StepSequencer>;
-type ISequence = {
-    active: boolean;
-    duration: string;
-    notes: INote[];
-};
+
 type IStepSequencerProps = {
-    bars: number;
-    steps: number;
-    sequences: ISequence[][];
+    patterns: IPattern[];
+    activePatternNo: number;
+    activePageNo: number;
+    stepsPerPage: number;
+    resolution: Resolution;
+    playbackMode: PlaybackMode;
+    patternSequence: string;
+    enableSequence: boolean;
+};
+type IStepSequencerState = {
+    isRunning: boolean;
+    currentStep: number;
+    sequencePosition?: string;
 };
-declare class StepSequencer extends Module<ModuleType.StepSequencer> {
+declare const stepPropSchema: ModulePropSchema<Pick<IStep, "probability" | "duration" | "microtimeOffset">, {
+    duration: EnumProp<Division>;
+}>;
+type StepSequencerSetterHooks = Pick<SetterHooks<IStepSequencerProps>, "onSetActivePatternNo" | "onAfterSetPatternSequence" | "onAfterSetPatterns" | "onAfterSetResolution" | "onAfterSetPlaybackMode" | "onAfterSetEnableSequence">;
+declare class StepSequencer extends Module<ModuleType.StepSequencer> implements StepSequencerSetterHooks {
     audioNode: undefined;
-    midiOutput: MidiOutput;
+    midiOutput: MidiOutput$1;
+    private scheduledNotes;
+    private source?;
     constructor(engineId: string, params: ICreateModule<ModuleType.StepSequencer>);
+    onSetActivePatternNo: StepSequencerSetterHooks["onSetActivePatternNo"];
+    onAfterSetPatternSequence: StepSequencerSetterHooks["onAfterSetPatternSequence"];
+    onAfterSetPatterns: StepSequencerSetterHooks["onAfterSetPatterns"];
+    onAfterSetResolution: StepSequencerSetterHooks["onAfterSetResolution"];
+    onAfterSetPlaybackMode: StepSequencerSetterHooks["onAfterSetPlaybackMode"];
+    onAfterSetEnableSequence: StepSequencerSetterHooks["onAfterSetEnableSequence"];
+    private initializeSource;
+    private handleStepEvent;
+    private registerOutputs;
+    private triggerStep;
+    private sendNoteOn;
+    private sendNoteOff;
+    private sendCC;
+    start(contextTime: ContextTime): void;
+    stop(contextTime: ContextTime): void;
+    dispose(): void;
 }
 
 type IStereoPannerProps = {
@@ -666,7 +956,7 @@ type IVirtualMidiProps = {
 };
 declare class VirtualMidi extends Module<ModuleType.VirtualMidi> {
     audioNode: undefined;
-    midiOutput: MidiOutput;
+    midiOutput: MidiOutput$1;
     constructor(engineId: string, params: ICreateModule<ModuleType.VirtualMidi>);
     sendMidi(midiEvent: MidiEvent): void;
     triggerAttack: (note: Note, triggerAttack: ContextTime) => void;
@@ -679,49 +969,97 @@ declare enum ModuleType {
     Master = "Master",
     Oscillator = "Oscillator",
     Gain = "Gain",
-    MidiSelector = "MidiSelector",
+    MidiInput = "MidiInput",
+    MidiOutput = "MidiOutput",
+    LegacyEnvelope = "LegacyEnvelope",// BACKWARD_COMPAT: Legacy envelope for old patches
     Envelope = "Envelope",
     Filter = "Filter",
     Scale = "Scale",
     StereoPanner = "StereoPanner",
     Inspector = "Inspector",
+    Chorus = "Chorus",
     Constant = "Constant",
+    Delay = "Delay",
+    Distortion = "Distortion",
     MidiMapper = "MidiMapper",
     VirtualMidi = "VirtualMidi",
     StepSequencer = "StepSequencer",
-    VoiceScheduler = "VoiceScheduler"
+    VoiceScheduler = "VoiceScheduler",
+    LFO = "LFO",
+    Noise = "Noise",
+    Reverb = "Reverb"
 }
 type ModuleTypeToPropsMapping = {
     [ModuleType.Oscillator]: IOscillatorProps;
     [ModuleType.Gain]: IGainProps;
     [ModuleType.Master]: IMasterProps;
-    [ModuleType.MidiSelector]: IMidiSelectorProps;
-    [ModuleType.Envelope]: IEnvelopeProps;
+    [ModuleType.MidiInput]: IMidiInputProps;
+    [ModuleType.MidiOutput]: IMidiOutputProps;
+    [ModuleType.LegacyEnvelope]: IEnvelopeProps;
+    [ModuleType.Envelope]: ICustomEnvelopeProps;
     [ModuleType.Filter]: IFilterProps;
     [ModuleType.Scale]: IScaleProps;
     [ModuleType.StereoPanner]: IStereoPannerProps;
     [ModuleType.Inspector]: IInspectorProps;
+    [ModuleType.Chorus]: IChorusProps;
     [ModuleType.Constant]: IConstantProps;
+    [ModuleType.Delay]: IDelayProps;
+    [ModuleType.Distortion]: IDistortionProps;
     [ModuleType.MidiMapper]: IMidiMapperProps;
     [ModuleType.VirtualMidi]: IVirtualMidiProps;
     [ModuleType.StepSequencer]: IStepSequencerProps;
     [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
+    [ModuleType.LFO]: ILFOProps;
+    [ModuleType.Noise]: INoiseProps;
+    [ModuleType.Reverb]: IReverbProps;
+};
+type ModuleTypeToStateMapping = {
+    [ModuleType.Oscillator]: never;
+    [ModuleType.Gain]: never;
+    [ModuleType.Master]: never;
+    [ModuleType.MidiInput]: never;
+    [ModuleType.MidiOutput]: never;
+    [ModuleType.LegacyEnvelope]: never;
+    [ModuleType.Envelope]: never;
+    [ModuleType.Filter]: never;
+    [ModuleType.Scale]: never;
+    [ModuleType.StereoPanner]: never;
+    [ModuleType.Inspector]: never;
+    [ModuleType.Chorus]: never;
+    [ModuleType.Constant]: never;
+    [ModuleType.Delay]: never;
+    [ModuleType.Distortion]: never;
+    [ModuleType.MidiMapper]: never;
+    [ModuleType.VirtualMidi]: never;
+    [ModuleType.StepSequencer]: IStepSequencerState;
+    [ModuleType.VoiceScheduler]: never;
+    [ModuleType.LFO]: never;
+    [ModuleType.Noise]: never;
+    [ModuleType.Reverb]: never;
 };
 type ModuleTypeToModuleMapping = {
     [ModuleType.Oscillator]: Oscillator;
     [ModuleType.Gain]: Gain;
     [ModuleType.Master]: Master;
-    [ModuleType.MidiSelector]: MidiSelector;
-    [ModuleType.Envelope]: Envelope;
+    [ModuleType.MidiInput]: MidiInput;
+    [ModuleType.MidiOutput]: MidiOutput;
+    [ModuleType.LegacyEnvelope]: Envelope;
+    [ModuleType.Envelope]: CustomEnvelope;
     [ModuleType.Filter]: Filter;
     [ModuleType.Scale]: Scale;
     [ModuleType.StereoPanner]: StereoPanner;
     [ModuleType.Inspector]: Inspector;
+    [ModuleType.Chorus]: Chorus;
     [ModuleType.Constant]: Constant;
+    [ModuleType.Delay]: Delay;
+    [ModuleType.Distortion]: PolyDistortion;
     [ModuleType.MidiMapper]: MidiMapper;
     [ModuleType.VirtualMidi]: VirtualMidi;
     [ModuleType.StepSequencer]: StepSequencer;
     [ModuleType.VoiceScheduler]: VoiceScheduler;
+    [ModuleType.LFO]: LFO;
+    [ModuleType.Noise]: Noise;
+    [ModuleType.Reverb]: Reverb;
 };
 declare const moduleSchemas: {
     Oscillator: ModulePropSchema<IOscillatorProps, {
@@ -729,21 +1067,47 @@ declare const moduleSchemas: {
     }>;
     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>;
+    MidiInput: ModulePropSchema<IMidiInputProps, _blibliki_utils.EmptyObject>;
+    MidiOutput: ModulePropSchema<IMidiOutputProps, _blibliki_utils.EmptyObject>;
+    LegacyEnvelope: ModulePropSchema<IEnvelopeProps, _blibliki_utils.EmptyObject>;
+    Envelope: ModulePropSchema<ICustomEnvelopeProps, _blibliki_utils.EmptyObject>;
     Filter: ModulePropSchema<IFilterProps, {
         type: EnumProp<BiquadFilterType>;
     }>;
-    Scale: ModulePropSchema<IScaleProps, _blibliki_utils.EmptyObject>;
+    Scale: ModulePropSchema<IScaleProps, {
+        mode: EnumProp<"exponential" | "linear">;
+    }>;
     StereoPanner: ModulePropSchema<IStereoPannerProps, _blibliki_utils.EmptyObject>;
     Inspector: ModulePropSchema<IInspectorProps, {
         fftSize: EnumProp<number>;
     }>;
+    Chorus: ModulePropSchema<IChorusProps, _blibliki_utils.EmptyObject>;
     Constant: ModulePropSchema<IConstantProps, _blibliki_utils.EmptyObject>;
+    Delay: ModulePropSchema<IDelayProps, {
+        timeMode: EnumProp<DelayTimeMode>;
+        division: EnumProp<_blibliki_transport.Division>;
+    }>;
+    Distortion: ModulePropSchema<IDistortionProps, _blibliki_utils.EmptyObject>;
     MidiMapper: ModulePropSchema<IMidiMapperProps, _blibliki_utils.EmptyObject>;
     VirtualMidi: ModulePropSchema<IVirtualMidiProps, _blibliki_utils.EmptyObject>;
-    StepSequencer: ModulePropSchema<Omit<IStepSequencerProps, "sequences">, _blibliki_utils.EmptyObject>;
+    StepSequencer: ModulePropSchema<Pick<IStepSequencerProps, "activePatternNo" | "activePageNo" | "stepsPerPage" | "resolution" | "playbackMode" | "patternSequence" | "enableSequence">, {
+        resolution: EnumProp<_blibliki_transport.Resolution>;
+        playbackMode: EnumProp<_blibliki_transport.PlaybackMode>;
+    }>;
     VoiceScheduler: ModulePropSchema<_blibliki_utils.EmptyObject, _blibliki_utils.EmptyObject>;
+    LFO: ModulePropSchema<ILFOProps, {
+        division: EnumProp<_blibliki_transport.Division>;
+        waveform: EnumProp<LFOWaveform>;
+    }>;
+    Noise: ModulePropSchema<INoiseProps, {
+        type: EnumProp<NoiseType>;
+    }>;
+    Reverb: ModulePropSchema<IReverbProps, {
+        type: {
+            kind: "enum";
+            options: ReverbType[];
+        };
+    }>;
 };
 
 type AnyModule = Module<ModuleType>;
@@ -754,10 +1118,10 @@ 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.StereoPanner | ModuleType.VoiceScheduler ? IPolyModuleConstructor<K> : ICreateModule<K>;
+    [K in ModuleType]: K extends ModuleType.Oscillator | ModuleType.Gain | ModuleType.LegacyEnvelope | ModuleType.Envelope | ModuleType.Filter | ModuleType.StereoPanner | ModuleType.VoiceScheduler | ModuleType.Scale | ModuleType.LFO | ModuleType.Distortion ? IPolyModuleConstructor<K> : ICreateModule<K>;
 }[ModuleType];
 
-type IAnyModuleSerialize = IModuleSerialize<ModuleType> | IPolyModuleSerialize<ModuleType>;
+type IAnyModuleSerialize<MT extends ModuleType = ModuleType> = IModuleSerialize<MT> | IPolyModuleSerialize<MT>;
 
 type IPlug = {
     moduleId: string;
@@ -783,9 +1147,17 @@ declare class Routes {
     private getIOs;
 }
 
-type ListenerCallback = (device: MidiDevice) => void;
+declare class MidiOutputDevice extends BaseMidiDevice<IMidiOutputPort> {
+    constructor(output: IMidiOutputPort);
+    connect(): void;
+    disconnect(): void;
+    send(data: number[] | Uint8Array, timestamp?: number): void;
+}
+
+type ListenerCallback = (device: MidiInputDevice | MidiOutputDevice) => void;
 declare class MidiDeviceManager {
-    devices: Map<string, MidiDevice | ComputerKeyboardInput>;
+    inputDevices: Map<string, MidiInputDevice | ComputerKeyboardInput>;
+    outputDevices: Map<string, MidiOutputDevice>;
     private initialized;
     private listeners;
     private context;
@@ -793,8 +1165,13 @@ declare class MidiDeviceManager {
     private adapter;
     constructor(context: Context);
     initialize(): Promise<void>;
-    find(id: string): MidiDevice | ComputerKeyboardInput | undefined;
-    findByName(name: string): MidiDevice | ComputerKeyboardInput | undefined;
+    find(id: string): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findByName(name: string): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findByFuzzyName(name: string, threshold?: number): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findInput(id: string): MidiInputDevice | ComputerKeyboardInput | undefined;
+    findInputByName(name: string): MidiInputDevice | ComputerKeyboardInput | undefined;
+    findOutput(id: string): MidiOutputDevice | undefined;
+    findOutputByName(name: string): MidiOutputDevice | undefined;
     /**
      * Finds a device using fuzzy name matching
      * Useful for matching devices across browser/Node.js environments where names differ
@@ -803,8 +1180,12 @@ declare class MidiDeviceManager {
      * @param threshold - Minimum similarity score (0-1, default: 0.6)
      * @returns The best matching device and confidence score, or null
      */
-    findByFuzzyName(targetName: string, threshold?: number): {
-        device: MidiDevice | ComputerKeyboardInput;
+    findInputByFuzzyName(targetName: string, threshold?: number): {
+        device: MidiInputDevice | ComputerKeyboardInput;
+        score: number;
+    } | null;
+    findOutputByFuzzyName(targetName: string, threshold?: number): {
+        device: MidiOutputDevice;
         score: number;
     } | null;
     addListener(callback: ListenerCallback): void;
@@ -835,7 +1216,7 @@ declare class Engine {
     context: Context;
     isInitialized: boolean;
     routes: Routes;
-    transport: Transport<TransportEvent>;
+    transport: Transport;
     modules: Map<string, ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]>;
     midiDeviceManager: MidiDeviceManager;
     static getById(id: string): Engine;
@@ -844,8 +1225,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.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>;
+    addModule<T extends ModuleType>(params: ICreateModule<T>): IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Distortion> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.LFO> | IPolyModuleSerialize<ModuleType.LegacyEnvelope> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.StereoPanner> | IModuleSerialize<ModuleType.Chorus> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.Delay> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiInput> | IModuleSerialize<ModuleType.MidiMapper> | IModuleSerialize<ModuleType.MidiOutput> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer> | IModuleSerialize<ModuleType.Noise> | IModuleSerialize<ModuleType.Reverb>;
+    updateModule<T extends ModuleType>(params: IUpdateModule<T>): IPolyModuleSerialize<ModuleType.VoiceScheduler> | IPolyModuleSerialize<ModuleType.Distortion> | IPolyModuleSerialize<ModuleType.Envelope> | IPolyModuleSerialize<ModuleType.Gain> | IPolyModuleSerialize<ModuleType.Scale> | IPolyModuleSerialize<ModuleType.Filter> | IPolyModuleSerialize<ModuleType.LFO> | IPolyModuleSerialize<ModuleType.LegacyEnvelope> | IPolyModuleSerialize<ModuleType.Oscillator> | IPolyModuleSerialize<ModuleType.StereoPanner> | IModuleSerialize<ModuleType.Chorus> | IModuleSerialize<ModuleType.Constant> | IModuleSerialize<ModuleType.Delay> | IModuleSerialize<ModuleType.Inspector> | IModuleSerialize<ModuleType.Master> | IModuleSerialize<ModuleType.MidiInput> | IModuleSerialize<ModuleType.MidiMapper> | IModuleSerialize<ModuleType.MidiOutput> | IModuleSerialize<ModuleType.VirtualMidi> | IModuleSerialize<ModuleType.StepSequencer> | IModuleSerialize<ModuleType.Noise> | IModuleSerialize<ModuleType.Reverb>;
     removeModule(id: string): void;
     addRoute(props: ICreateRoute): IRoute;
     removeRoute(id: string): void;
@@ -862,17 +1243,30 @@ declare class Engine {
     serialize(): IEngineSerialize;
     findModule(id: string): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping];
     findIO(moduleId: string, ioName: string, type: "input" | "output"): Base;
-    findMidiDevice(id: string): MidiDevice | ComputerKeyboardInput | undefined;
-    findMidiDeviceByName(name: string): MidiDevice | ComputerKeyboardInput | undefined;
-    findMidiDeviceByFuzzyName(name: string, threshold?: number): {
-        device: MidiDevice | ComputerKeyboardInput;
+    findMidiDevice(id: string): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findMidiDeviceByName(name: string): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findMidiDeviceByFuzzyName(name: string, threshold?: number): MidiInputDevice | ComputerKeyboardInput | MidiOutputDevice | undefined;
+    findMidiInputDevice(id: string): MidiInputDevice | ComputerKeyboardInput | undefined;
+    findMidiInputDeviceByName(name: string): MidiInputDevice | ComputerKeyboardInput | undefined;
+    findMidiInputDeviceByFuzzyName(name: string, threshold?: number): {
+        device: MidiInputDevice | ComputerKeyboardInput;
         score: number;
     } | null;
-    onPropsUpdate(callback: <T extends ModuleType>(params: IModule<T> | IPolyModule<T>) => void): void;
-    _triggerPropsUpdate<T extends ModuleType>(params: IModule<T> | IPolyModule<T>): void;
+    findMidiOutputDevice(id: string): MidiOutputDevice | undefined;
+    findMidiOutputDeviceByName(name: string): MidiOutputDevice | undefined;
+    findMidiOutputDeviceByFuzzyName(name: string, threshold?: number): {
+        device: MidiOutputDevice;
+        score: number;
+    } | null;
+    onPropsUpdate(callback: <T extends ModuleType>(params: (IModule<T> | IPolyModule<T>) & {
+        state?: ModuleTypeToStateMapping[T];
+    }) => void): void;
+    _triggerPropsUpdate<T extends ModuleType>(params: (IModule<T> | IPolyModule<T>) & {
+        state?: ModuleTypeToStateMapping[T];
+    }): void;
     triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
     private onStart;
     private onStop;
 }
 
-export { type ArrayProp, type BooleanProp, Engine, type EnumProp, type IAnyModuleSerialize, type ICreateModule, type ICreateRoute, type IEngineSerialize, 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 };
+export { type ArrayProp, type BooleanProp, DelayTimeMode, Engine, type EnumProp, type IAnyModuleSerialize, type ICreateModule, type ICreateRoute, type IEngineSerialize, type IGain, type IIOSerialize, type ILFO, type ILFOProps, type IMaster, type IMidiDevice, type IMidiMapper, type IMidiMapperProps, type IModule, type IModuleSerialize, type INoise, type INote, type IOscillator, type IPolyModuleSerialize, type IRoute, type IStepSequencer, type IStepSequencerProps, type IStepSequencerState, type IUpdateModule, LFOWaveform, MidiInputDevice as MidiDevice, MidiInputDevice, type MidiMapping, MidiMappingMode, MidiOutputDevice, MidiPortState, type ModuleParams, type ModulePropSchema, ModuleType, type ModuleTypeToPropsMapping, type ModuleTypeToStateMapping, NoiseType, Note, type NumberProp, OscillatorWave, type PropSchema, type SetterHooks, type StateSetterHooks, StepSequencer, type StringProp, moduleSchemas, stepPropSchema };