@blibliki/engine 0.3.10 → 0.4.2

package/dist/index.d.cts

@@ -1,860 +0,0 @@
-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';
-
-/**
- * Simple wrapper around MIDI message data (Uint8Array)
- * Replaces the webmidi Message class with native Web MIDI API data
- */
-declare class Message {
-    readonly data: Uint8Array;
-    constructor(data: Uint8Array);
-    /**
-     * Returns the data bytes (excluding the status byte)
-     */
-    get dataBytes(): number[];
-    /**
-     * Returns the MIDI message type based on the status byte
-     */
-    get type(): string;
-}
-
-type INote = {
-    name: string;
-    octave: number;
-    frequency: number;
-    duration?: Seconds;
-    velocity?: number;
-};
-declare class Note implements INote {
-    static _notes: Note[];
-    name: string;
-    octave: number;
-    velocity: number;
-    duration?: Seconds;
-    static fromFrequency(frequency: number): Note;
-    static fromEvent(message: Message): Note;
-    static notes(octave?: number): Note[];
-    constructor(note: Omit<INote, "frequency"> | string);
-    get isSemi(): boolean;
-    get fullName(): string;
-    get frequency(): number;
-    midiData(noteOn?: boolean): Uint8Array;
-    get midiNumber(): number;
-    get noteIndex(): number;
-    valueOf(): string;
-    serialize(): INote;
-    private fromString;
-    private fromProps;
-}
-
-declare enum MidiEventType {
-    noteOn = "noteon",
-    noteOff = "noteoff",
-    cc = "controlchange"
-}
-declare class MidiEvent {
-    note?: Note;
-    voiceNo?: number;
-    readonly triggeredAt: ContextTime;
-    private message;
-    static fromNote(noteName: string | Note | Omit<INote, "frequency">, noteOn: boolean | undefined, triggeredAt: ContextTime): MidiEvent;
-    static fromCC(cc: number, value: number, triggeredAt: ContextTime): 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;
-}
-
-/**
- * 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 = {
-    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;
-    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;
-}
-
-declare class ComputerKeyboardInput implements IMidiInput {
-    id: string;
-    name: string;
-    state: MidiPortState;
-    eventListerCallbacks: EventListerCallback[];
-    private context;
-    constructor(context: Context);
-    addEventListener(callback: EventListerCallback): void;
-    removeEventListener(callback: EventListerCallback): void;
-    serialize(): {
-        id: string;
-        name: string;
-        state: MidiPortState;
-    };
-    onKeyTrigger: (noteOn: boolean) => (event: KeyboardEvent) => void;
-    private extractNote;
-}
-
-type MidiInputProps = IOProps & {
-    ioType: IOType.MidiInput;
-    onMidiEvent: (event: MidiEvent) => void;
-};
-type MidiOutputProps = IOProps & {
-    ioType: IOType.MidiOutput;
-};
-declare class MidiInput extends IO<MidiOutput> implements MidiInputProps {
-    ioType: IOType.MidiInput;
-    onMidiEvent: MidiInputProps["onMidiEvent"];
-    constructor(module: Module<ModuleType> | PolyModule<ModuleType>, props: MidiInputProps);
-}
-declare class MidiOutput extends IO<MidiInput> implements MidiOutputProps {
-    ioType: IOType.MidiOutput;
-    onMidiEvent: (event: MidiEvent) => void;
-    private get midiConnections();
-}
-
-type IOProps = {
-    name: string;
-    ioType: IOType;
-};
-type IIOSerialize = IOProps & {
-    id: string;
-    moduleId: string;
-};
-declare enum IOType {
-    AudioInput = "audioInput",
-    AudioOutput = "audioOutput",
-    PolyAudioInput = "polyAudioInput",
-    PolyAudioOutput = "polyAudioOutput",
-    MidiOutput = "midiOutput",
-    MidiInput = "midiInput"
-}
-type IIO = {
-    id: string;
-    module: Module<ModuleType> | PolyModule<ModuleType>;
-} & IOProps;
-declare abstract class Base implements IIO {
-    id: string;
-    ioType: IOType;
-    name: string;
-    module: Module<ModuleType> | PolyModule<ModuleType>;
-    connections: Base[];
-    constructor(module: Module<ModuleType> | PolyModule<ModuleType>, props: IOProps);
-    plug(io: Base, plugOther?: boolean): void;
-    unPlug(io: Base, plugOther?: boolean): void;
-    rePlugAll(callback?: () => void): void;
-    unPlugAll(): void;
-    isAudio(): this is AudioInput | AudioOutput | PolyAudioInput | PolyAudioOutput;
-    isMidi(): this is MidiInput | MidiOutput;
-    serialize(): IIOSerialize;
-}
-declare abstract class IO<Connection extends Base> extends Base {
-    connections: Connection[];
-    plug(io: Connection, plugOther?: boolean): void;
-    unPlug(io: Connection, plugOther?: boolean): void;
-}
-
-type AudioInputProps = IOProps & {
-    ioType: IOType.AudioInput;
-    getAudioNode: () => AudioNode | AudioParam | AudioDestinationNode;
-};
-type AudioOutputProps = IOProps & {
-    ioType: IOType.AudioOutput;
-    getAudioNode: () => AudioNode;
-};
-declare class AudioInput extends IO<AudioOutput | PolyAudioOutput> implements AudioInputProps {
-    ioType: IOType.AudioInput;
-    getAudioNode: AudioInputProps["getAudioNode"];
-    constructor(module: Module<ModuleType>, props: AudioInputProps);
-}
-declare class AudioOutput extends IO<AudioInput | PolyAudioInput> implements AudioOutputProps {
-    ioType: IOType.AudioOutput;
-    getAudioNode: AudioOutputProps["getAudioNode"];
-    constructor(module: Module<ModuleType>, props: AudioOutputProps);
-    plug(io: AudioInput | PolyAudioInput, plugOther?: boolean): void;
-    unPlug(io: AudioInput | PolyAudioInput, plugOther?: boolean): void;
-}
-
-type PolyAudioInputProps = IOProps & {
-    ioType: IOType.PolyAudioInput;
-};
-type PolyAudioOutputProps = IOProps & {
-    ioType: IOType.PolyAudioOutput;
-};
-declare class PolyAudioInput extends IO<PolyAudioOutput | AudioOutput> implements PolyAudioInputProps {
-    ioType: IOType.PolyAudioInput;
-    module: PolyModule<ModuleType>;
-    plug(io: PolyAudioOutput | AudioOutput, plugOther?: boolean): void;
-    unPlug(io: PolyAudioOutput | AudioOutput, plugOther?: boolean): void;
-    findIOByVoice(voice: number): AudioInput;
-}
-declare class PolyAudioOutput extends IO<PolyAudioInput | AudioInput> implements PolyAudioOutputProps {
-    ioType: IOType.PolyAudioOutput;
-    module: PolyModule<ModuleType>;
-    plug(io: PolyAudioInput | AudioInput, plugOther?: boolean): void;
-    unPlug(io: PolyAudioInput | AudioInput, plugOther?: boolean): void;
-    findIOByVoice(voice: number): AudioOutput;
-}
-
-declare enum CollectionType {
-    Input = "Input",
-    Output = "Output"
-}
-type IMappedIOProps = {
-    [CollectionType.Input]: AudioInputProps | PolyAudioInputProps | MidiInputProps;
-    [CollectionType.Output]: AudioOutputProps | PolyAudioOutputProps | MidiOutputProps;
-};
-type IIOTypeTOClass = {
-    [IOType.AudioInput]: AudioInput;
-    [IOType.AudioOutput]: AudioOutput;
-    [IOType.PolyAudioInput]: PolyAudioInput;
-    [IOType.PolyAudioOutput]: PolyAudioOutput;
-    [IOType.MidiInput]: MidiInput;
-    [IOType.MidiOutput]: MidiOutput;
-};
-declare abstract class IOCollection<T extends CollectionType> {
-    module: Module<ModuleType> | PolyModule<ModuleType>;
-    collection: Base[];
-    collectionType: T;
-    constructor(collectionType: T, module: Module<ModuleType> | PolyModule<ModuleType>);
-    add<TT extends IMappedIOProps[T]>(props: TT): IIOTypeTOClass[TT["ioType"]];
-    unPlugAll(): void;
-    rePlugAll(callback?: () => void): void;
-    find(id: string): Base;
-    findByName(name: string): Base;
-    serialize(): IIOSerialize[];
-    private validateUniqName;
-}
-declare class InputCollection extends IOCollection<CollectionType.Input> {
-    constructor(module: Module<ModuleType> | PolyModule<ModuleType>);
-}
-declare class OutputCollection extends IOCollection<CollectionType.Output> {
-    constructor(module: Module<ModuleType> | PolyModule<ModuleType>);
-}
-
-type IPolyModule<T extends ModuleType> = Omit<IModule<T>, "voiceNo"> & {
-    voices: number;
-};
-type IPolyModuleSerialize<T extends ModuleType> = IPolyModule<T> & {
-    inputs: IIOSerialize[];
-    outputs: IIOSerialize[];
-};
-type IPolyModuleConstructor<T extends ModuleType> = Optional<IPolyModule<T>, "id"> & {
-    monoModuleConstructor: (engineId: string, params: IModuleConstructor<T>) => Module<T>;
-};
-declare abstract class PolyModule<T extends ModuleType> implements IPolyModule<T> {
-    id: string;
-    engineId: string;
-    moduleType: T;
-    audioModules: Module<T>[];
-    inputs: InputCollection;
-    outputs: OutputCollection;
-    protected monoModuleConstructor: IPolyModuleConstructor<T>["monoModuleConstructor"];
-    protected _props: ModuleTypeToPropsMapping[T];
-    private _voices;
-    private _name;
-    private pendingUIUpdates;
-    constructor(engineId: string, params: IPolyModuleConstructor<T>);
-    get name(): string;
-    set name(value: string);
-    get props(): ModuleTypeToPropsMapping[T];
-    set props(value: Partial<ModuleTypeToPropsMapping[T]>);
-    get voices(): number;
-    set voices(value: number);
-    start(time: ContextTime): void;
-    stop(time: ContextTime): void;
-    serialize(): IPolyModuleSerialize<T>;
-    plug({ audioModule, from, to, }: {
-        audioModule: Module<ModuleType> | PolyModule<ModuleType>;
-        from: string;
-        to: string;
-    }): void;
-    rePlugAll(callback?: () => void): void;
-    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;
-    protected registerAudioOutput(props: Omit<PolyAudioOutputProps, "ioType">): PolyAudioOutput;
-    protected registerMidiInput(props: Omit<MidiInputProps, "ioType">): MidiInput;
-    protected registerMidiOutput(props: Omit<MidiOutputProps, "ioType">): MidiOutput;
-    private adjustNumberOfModules;
-    protected get engine(): Engine;
-    protected get context(): _blibliki_utils.Context;
-}
-
-type BasePropType = {
-    label?: string;
-    description?: string;
-};
-type NumberProp = BasePropType & {
-    kind: "number";
-    min?: number;
-    max?: number;
-    step?: number;
-    exp?: number;
-};
-type EnumProp<T extends string | number> = BasePropType & {
-    kind: "enum";
-    options: T[];
-};
-type StringProp = BasePropType & {
-    kind: "string";
-    pattern?: RegExp;
-};
-type BooleanProp = BasePropType & {
-    kind: "boolean";
-};
-type ArrayProp = BasePropType & {
-    kind: "array";
-};
-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;
-    activeNote: string | null;
-    triggeredAt: ContextTime;
-    constructor(engineId: string, params: ICreateModule<ModuleType.VoiceScheduler>);
-    midiTriggered: (midiEvent: MidiEvent) => void;
-}
-declare class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler> {
-    audioModules: Voice[];
-    midiOutput: MidiOutput;
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.VoiceScheduler>);
-    onMidiEvent: (midiEvent: MidiEvent) => void;
-    private findFreeVoice;
-    private registerInputs;
-    private registerOutputs;
-}
-
-type IConstantProps = {
-    value: number;
-};
-declare class Constant extends Module<ModuleType.Constant> implements Pick<SetterHooks<IConstantProps>, "onAfterSetValue"> {
-    audioNode: ConstantSourceNode;
-    isStated: boolean;
-    constructor(engineId: string, params: ICreateModule<ModuleType.Constant>);
-    onAfterSetValue: SetterHooks<IConstantProps>["onAfterSetValue"];
-    start(time: ContextTime): void;
-    stop(time: ContextTime): void;
-    triggerAttack: (note: Note, triggeredAt: ContextTime) => void;
-    triggerRelease: () => void;
-}
-
-type IEnvelopeProps = {
-    attack: number;
-    decay: number;
-    sustain: number;
-    release: number;
-};
-declare class Envelope extends PolyModule<ModuleType.Envelope> {
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Envelope>);
-}
-
-type IFilterProps = {
-    cutoff: number;
-    envelopeAmount: number;
-    type: BiquadFilterType;
-    Q: number;
-};
-declare class Filter extends PolyModule<ModuleType.Filter> {
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Filter>);
-    private registerInputs;
-}
-
-type IGain = IModule<ModuleType.Gain>;
-type IGainProps = {
-    gain: number;
-};
-declare class Gain extends PolyModule<ModuleType.Gain> {
-    constructor(engineId: string, params: IPolyModuleConstructor<ModuleType.Gain>);
-    private registerAdditionalInputs;
-}
-
-type IInspectorProps = {
-    fftSize: number;
-};
-declare class Inspector extends Module<ModuleType.Inspector> implements Pick<SetterHooks<IInspectorProps>, "onAfterSetFftSize"> {
-    audioNode: AnalyserNode;
-    private _buffer?;
-    constructor(engineId: string, params: ICreateModule<ModuleType.Inspector>);
-    onAfterSetFftSize: SetterHooks<IInspectorProps>["onAfterSetFftSize"];
-    get buffer(): Float32Array<ArrayBuffer>;
-    getValue(): number;
-    getValues(): Float32Array;
-}
-
-type IMaster = IModule<ModuleType.Master>;
-type IMasterProps = EmptyObject;
-declare class Master extends Module<ModuleType.Master> {
-    audioNode: AudioDestinationNode;
-    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;
-    selectedName: string | undefined | null;
-};
-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>);
-    onSetSelectedId: SetterHooks<IMidiSelectorProps>["onSetSelectedId"];
-    private get forwardMidiEvent();
-    private addEventListener;
-    private removeEventListener;
-    private registerOutputs;
-}
-
-type IScaleProps = {
-    min: number;
-    max: number;
-    current: number;
-};
-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"];
-}
-
-type IStepSequencer = IModule<ModuleType.StepSequencer>;
-type ISequence = {
-    active: boolean;
-    duration: string;
-    notes: INote[];
-};
-type IStepSequencerProps = {
-    bars: number;
-    steps: number;
-    sequences: ISequence[][];
-};
-declare class StepSequencer extends Module<ModuleType.StepSequencer> {
-    audioNode: undefined;
-    midiOutput: MidiOutput;
-    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[];
-};
-declare class VirtualMidi extends Module<ModuleType.VirtualMidi> {
-    audioNode: undefined;
-    midiOutput: MidiOutput;
-    constructor(engineId: string, params: ICreateModule<ModuleType.VirtualMidi>);
-    sendMidi(midiEvent: MidiEvent): void;
-    triggerAttack: (note: Note, triggerAttack: ContextTime) => void;
-    triggerRelease: (note: Note, triggerAttack: ContextTime) => void;
-    private registerInputs;
-    private registerOutputs;
-}
-
-declare enum ModuleType {
-    Master = "Master",
-    Oscillator = "Oscillator",
-    Gain = "Gain",
-    MidiSelector = "MidiSelector",
-    Envelope = "Envelope",
-    Filter = "Filter",
-    Scale = "Scale",
-    StereoPanner = "StereoPanner",
-    Inspector = "Inspector",
-    Constant = "Constant",
-    MidiMapper = "MidiMapper",
-    VirtualMidi = "VirtualMidi",
-    StepSequencer = "StepSequencer",
-    VoiceScheduler = "VoiceScheduler"
-}
-type ModuleTypeToPropsMapping = {
-    [ModuleType.Oscillator]: IOscillatorProps;
-    [ModuleType.Gain]: IGainProps;
-    [ModuleType.Master]: IMasterProps;
-    [ModuleType.MidiSelector]: IMidiSelectorProps;
-    [ModuleType.Envelope]: IEnvelopeProps;
-    [ModuleType.Filter]: IFilterProps;
-    [ModuleType.Scale]: IScaleProps;
-    [ModuleType.StereoPanner]: IStereoPannerProps;
-    [ModuleType.Inspector]: IInspectorProps;
-    [ModuleType.Constant]: IConstantProps;
-    [ModuleType.MidiMapper]: IMidiMapperProps;
-    [ModuleType.VirtualMidi]: IVirtualMidiProps;
-    [ModuleType.StepSequencer]: IStepSequencerProps;
-    [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
-};
-type ModuleTypeToModuleMapping = {
-    [ModuleType.Oscillator]: Oscillator;
-    [ModuleType.Gain]: Gain;
-    [ModuleType.Master]: Master;
-    [ModuleType.MidiSelector]: MidiSelector;
-    [ModuleType.Envelope]: Envelope;
-    [ModuleType.Filter]: Filter;
-    [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: {
-    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>;
-type ICreateModule<T extends ModuleType> = {
-    id?: string;
-    name: string;
-    moduleType: T;
-    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>;
-}[ModuleType];
-
-type IModule<T extends ModuleType> = {
-    id: string;
-    name: string;
-    voiceNo: number;
-    moduleType: T;
-    props: ModuleTypeToPropsMapping[T];
-};
-type IModuleSerialize<T extends ModuleType> = IModule<T> & {
-    inputs: IIOSerialize[];
-    outputs: IIOSerialize[];
-};
-type IModuleConstructor<T extends ModuleType> = Optional<IModule<T>, "id" | "voiceNo"> & {
-    audioNodeConstructor?: (context: Context) => AudioNode;
-};
-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;
-    name: string;
-    moduleType: T;
-    voiceNo: number;
-    audioNode: AudioNode | undefined;
-    inputs: InputCollection;
-    outputs: OutputCollection;
-    protected _props: ModuleTypeToPropsMapping[T];
-    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;
-        from: string;
-        to: string;
-    }): void;
-    protected rePlugAll(callback?: () => void): void;
-    protected unPlugAll(): void;
-    start(_time: ContextTime): void;
-    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;
-    triggerPropsUpdate: () => void;
-    private sheduleTriggerUpdate;
-    dispose(): void;
-    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 get engine(): Engine;
-    protected get context(): Context;
-}
-
-type IPlug = {
-    moduleId: string;
-    ioName: string;
-};
-type IRoute = {
-    id: string;
-    source: IPlug;
-    destination: IPlug;
-};
-declare class Routes {
-    engine: Engine;
-    routes: Map<string, IRoute>;
-    constructor(engine: Engine);
-    addRoute(props: Optional<IRoute, "id">): IRoute;
-    removeRoute(id: string): void;
-    clear(): void;
-    replug(): void;
-    serialize(): IRoute[];
-    private plug;
-    private unPlug;
-    private find;
-    private getIOs;
-}
-
-type ListenerCallback = (device: MidiDevice) => void;
-declare class MidiDeviceManager {
-    devices: Map<string, MidiDevice | ComputerKeyboardInput>;
-    private initialized;
-    private listeners;
-    private context;
-    private midiAccess;
-    private adapter;
-    constructor(context: Context);
-    initialize(): Promise<void>;
-    find(id: string): MidiDevice | ComputerKeyboardInput | undefined;
-    findByName(name: string): MidiDevice | ComputerKeyboardInput | undefined;
-    addListener(callback: ListenerCallback): void;
-    private initializeDevices;
-    private addComputerKeyboard;
-    private listenChanges;
-}
-
-type IUpdateModule<T extends ModuleType> = {
-    id: string;
-    moduleType: T;
-    changes: Partial<Omit<ICreateModule<T>, "id" | "moduleType" | "voice">> & {
-        voices?: number;
-    };
-};
-type ICreateRoute = Optional<IRoute, "id">;
-interface IEngineSerialize {
-    bpm: BPM;
-    timeSignature: TimeSignature;
-    modules: (IModuleSerialize<ModuleType> | IPolyModuleSerialize<ModuleType>)[];
-    routes: IRoute[];
-}
-declare class Engine {
-    private static _engines;
-    private static _currentId;
-    private propsUpdateCallbacks;
-    readonly id: string;
-    context: Context;
-    isInitialized: boolean;
-    routes: Routes;
-    transport: Transport<TransportEvent>;
-    modules: Map<string, ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]>;
-    midiDeviceManager: MidiDeviceManager;
-    static getById(id: string): Engine;
-    static get current(): Engine;
-    static load(data: IEngineSerialize): Promise<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>;
-    removeModule(id: string): void;
-    addRoute(props: ICreateRoute): IRoute;
-    removeRoute(id: string): void;
-    validRoute(props: Optional<IRoute, "id">): boolean;
-    start(): Promise<void>;
-    stop(): void;
-    pause(): void;
-    get bpm(): number;
-    set bpm(value: number);
-    get timeSignature(): TimeSignature;
-    set timeSignature(value: TimeSignature);
-    resume(): Promise<void>;
-    dispose(): void;
-    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;
-    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 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 };