@blibliki/engine 0.1.17 → 0.1.19

package/README.md

@@ -52,7 +52,19 @@ The props structure vary per audioModule.
 {
   id: string,
   name: string,
-  props: Object
+  props: Object,
+  inputs: [{
+    id: string,
+    name: string,
+    moduleId: string,
+    moduleName: string
+  }],
+  outputs: [{
+    id: string,
+    name: string,
+    moduleId: string,
+    moduleName: string
+  }],
 }
 ```
 

package/{build → dist/build}/Engine.d.ts

@@ -1,8 +1,8 @@
-import MidiDeviceManager from "./MidiDeviceManager";
-import { EType } from "./MidiEvent";
-import { AudioModule } from "./Module";
-import { RouteInterface, RouteProps } from "./routes";
-declare type LatencyHint = "interactive" | "playback" | "balanced";
+import { MidiDeviceManager } from "./core/midi";
+import { AudioModule } from "./core/Module";
+import { RouteInterface } from "./routes";
+import { AnyObject, Optional } from "./types";
+type LatencyHint = "interactive" | "playback" | "balanced";
 interface ContextInterface {
     latencyHint: LatencyHint;
     lookAhead: number;
@@ -13,7 +13,6 @@ interface InitializeInterface {
 declare class Engine {
     midiDeviceManager: MidiDeviceManager;
     private static instance;
-    private _master;
     private context;
     private propsUpdateCallbacks;
     private _isStarted;
@@ -27,9 +26,10 @@ declare class Engine {
     static getInstance(): Engine;
     initialize(props: InitializeInterface): Promise<unknown>;
     addModule(params: {
+        id?: string;
         name: string;
         type: string;
-        props?: any;
+        props?: AnyObject;
     }): {
         id: string;
         name: string;
@@ -47,9 +47,9 @@ declare class Engine {
         inputs: import(".").IOProps[];
         outputs: import(".").IOProps[];
     };
-    onPropsUpdate(callback: (id: string, props: any) => void): void;
-    _triggerPropsUpdate(id: string, props: any): void;
-    updatePropsModule(id: string, props: any): {
+    onPropsUpdate(callback: (id: string, props: AnyObject) => void): void;
+    _triggerPropsUpdate(id: string, props: AnyObject): void;
+    updatePropsModule(id: string, props: AnyObject): {
         id: string;
         name: string;
         type: string;
@@ -57,23 +57,15 @@ declare class Engine {
         inputs: import(".").IOProps[];
         outputs: import(".").IOProps[];
     };
-    addRoute(props: RouteProps): {
+    addRoute(props: Optional<RouteInterface, "id">): {
         id: string;
         sourceId: string;
-        outputName: string;
+        sourceIOId: string;
         destinationId: string;
-        inputName: string;
+        destinationIOId: string;
     };
     removeRoute(id: string): void;
-    get master(): {
-        id: string;
-        name: string;
-        type: string;
-        props: any;
-        inputs: import(".").IOProps[];
-        outputs: import(".").IOProps[];
-    };
-    triggerVirtualMidi(id: string, noteName: string, type: EType): void;
+    triggerVirtualMidi(id: string, noteName: string, type: "noteOn" | "noteOff"): void;
     dispose(): void;
     findById(id: string): AudioModule;
     get isStarted(): boolean;

package/dist/build/core/IO/AudioNode.d.ts

@@ -0,0 +1,35 @@
+import { InputNode } from "tone";
+import IONode, { IOType, IIONode } from "./Node";
+import MonoModule, { Connectable } from "../Module/index";
+import { AnyObject } from "../../types";
+import { ForwardInput, ForwardOutput } from "./ForwardNode";
+export type AudioIO = AudioInput | AudioOutput;
+export interface IAudioInput extends IIONode {
+    ioType: IOType.AudioInput;
+    internalModule: InputNode;
+}
+export interface IAudioOutput extends IIONode {
+    ioType: IOType.AudioOutput;
+    internalModule: IInternalModule;
+}
+interface IInternalModule extends Connectable {
+}
+export declare class AudioInput extends IONode implements IAudioInput {
+    ioType: IOType.AudioInput;
+    internalModule: InputNode;
+    connections: AudioOutput[];
+    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioInput);
+    plug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
+    unPlug(io: AudioOutput | ForwardOutput, plugOther?: boolean): void;
+    unPlugAll(): void;
+}
+export declare class AudioOutput extends IONode implements IAudioOutput {
+    ioType: IOType.AudioOutput;
+    internalModule: IInternalModule;
+    connections: AudioInput[];
+    constructor(plugableModule: MonoModule<Connectable, AnyObject>, props: IAudioOutput);
+    plug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
+    unPlug(io: AudioInput | ForwardInput, plugOther?: boolean): void;
+    unPlugAll(): void;
+}
+export {};

package/dist/build/core/IO/Collection.d.ts

@@ -0,0 +1,13 @@
+import { AudioModule } from "../Module";
+import IO from "./Node";
+import { IAnyIO } from ".";
+export default class IOCollection<AnyIO extends IO> {
+    plugableModule: AudioModule;
+    collection: AnyIO[];
+    constructor(plugableModule: AudioModule);
+    add<CurrentIO extends AnyIO>(props: IAnyIO): CurrentIO;
+    unPlugAll(): void;
+    find(id: string): AnyIO | undefined;
+    findByName(name: string): AnyIO | undefined;
+    serialize(): import("./Node").IIOSerialize[];
+}

package/dist/build/core/IO/ForwardNode.d.ts

@@ -0,0 +1,38 @@
+import IONode, { IOType, IIONode } from "./Node";
+import Module, { Connectable, PolyModule } from "../Module";
+import { AnyObject } from "../../types";
+import { AnyInput, AnyOuput } from ".";
+export interface IForwardInput extends IIONode {
+    ioType: IOType.ForwardInput;
+}
+export interface IForwardOutput extends IIONode {
+    ioType: IOType.ForwardOutput;
+}
+export declare class ForwardInput extends IONode implements IForwardInput {
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+    ioType: IOType.ForwardInput;
+    connections: ForwardOutput[];
+    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardInput);
+    get subInputs(): (import("./AudioNode").AudioInput | import("./MidiNode").MidiInput)[];
+    get subModules(): Module<Connectable, AnyObject>[];
+    subModule(voiceNo: number): Module<Connectable, AnyObject>;
+    subInput(voiceNo: number): import("./AudioNode").AudioInput | import("./MidiNode").MidiInput;
+    plug(io: AnyOuput, plugOther?: boolean): void;
+    unPlug(io: AnyOuput, plugOther?: boolean): void;
+    unPlugAll(): void;
+    private checkNameValidity;
+}
+export declare class ForwardOutput extends IONode implements IForwardOutput {
+    plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>;
+    ioType: IOType.ForwardOutput;
+    connections: ForwardInput[];
+    constructor(plugableModule: PolyModule<Module<Connectable, AnyObject>, AnyObject>, props: IForwardOutput);
+    get subOutputs(): (import("./AudioNode").AudioOutput | import("./MidiNode").MidiOutput)[];
+    get subModules(): Module<Connectable, AnyObject>[];
+    subModule(voiceNo: number): Module<Connectable, AnyObject>;
+    subOutput(voiceNo: number): import("./AudioNode").AudioOutput | import("./MidiNode").MidiOutput;
+    plug(io: AnyInput, plugOther?: boolean): void;
+    unPlug(io: AnyInput, plugOther?: boolean): void;
+    unPlugAll(): void;
+    private checkNameValidity;
+}

package/dist/build/core/IO/MidiNode.d.ts

@@ -0,0 +1,30 @@
+import { AudioModule } from "../Module";
+import { MidiEvent } from "../midi";
+import { ForwardInput, ForwardOutput } from "./ForwardNode";
+import IONode, { IOType, IIONode } from "./Node";
+export interface IMidiInput extends IIONode {
+    ioType: IOType.MidiInput;
+    onMidiEvent: (event: MidiEvent) => void;
+}
+export interface IMidiOutput extends IIONode {
+    ioType: IOType.MidiOutput;
+}
+export declare class MidiInput extends IONode implements IMidiInput {
+    ioType: IOType.MidiInput;
+    connections: MidiOutput[];
+    onMidiEvent: (event: MidiEvent) => void;
+    constructor(plugableModule: AudioModule, props: IMidiInput);
+    plug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
+    unPlug(io: MidiOutput | ForwardOutput, plugOther?: boolean): void;
+    unPlugAll(): void;
+}
+export declare class MidiOutput extends IONode implements IMidiOutput {
+    ioType: IOType.MidiOutput;
+    connections: MidiInput[];
+    constructor(plugableModule: AudioModule, props: IIONode);
+    plug(io: MidiInput | ForwardInput, plugOther?: boolean): void;
+    unPlug(io: MidiInput | ForwardOutput, plugOther?: boolean): void;
+    unPlugAll(): void;
+    onMidiEvent: (event: MidiEvent) => void;
+    private get midiConnections();
+}

package/dist/build/core/IO/Node.d.ts

@@ -0,0 +1,36 @@
+import { AudioModule } from "../Module";
+import { AnyInput, AnyOuput } from ".";
+export interface IIONode {
+    name: string;
+    ioType: IOType;
+}
+export interface IIOSerialize {
+    id: string;
+    name: string;
+    ioType: IOType;
+    moduleId: string;
+    moduleName: string;
+}
+export declare enum IOType {
+    AudioInput = "audioInput",
+    AudioOutput = "audioOutput",
+    MidiInput = "midiInput",
+    MidiOutput = "midiOutput",
+    ForwardInput = "forwardInput",
+    ForwardOutput = "forwardOutput"
+}
+export declare function plugCompatibleIO(input: AnyInput, output: AnyOuput): void;
+export declare function unPlugCompatibleIO(input: AnyInput, output: AnyOuput): void;
+export default abstract class IONode implements IIONode {
+    id: string;
+    ioType: IOType;
+    name: string;
+    plugableModule: AudioModule;
+    connections: IONode[];
+    static unPlugAll(io: IONode): void;
+    constructor(plugableModule: AudioModule, props: IIONode);
+    plug(io: IONode, plugOther?: boolean): void;
+    unPlug(io: IONode, plugOther?: boolean): void;
+    abstract unPlugAll(): void;
+    serialize(): IIOSerialize;
+}

package/dist/build/core/IO/index.d.ts

@@ -0,0 +1,12 @@
+import { default as IOCollection } from "./Collection";
+import { IIONode, IOType, IIOSerialize } from "./Node";
+import { AudioInput, AudioOutput, IAudioInput, IAudioOutput } from "./AudioNode";
+import { IMidiInput, IMidiOutput, MidiInput, MidiOutput } from "./MidiNode";
+import { ForwardInput, ForwardOutput, IForwardInput, IForwardOutput } from "./ForwardNode";
+type AnyInput = AudioInput | MidiInput | ForwardInput;
+type AnyOuput = AudioOutput | MidiOutput | ForwardOutput;
+type IAnyInput = IAudioInput | IMidiInput | IForwardInput;
+type IAnyOutput = IAudioOutput | IMidiOutput | IForwardOutput;
+type IAnyIO = IAnyInput | IAnyOutput | IForwardOutput;
+export { IOCollection, IOType, AudioInput, AudioOutput, MidiInput, MidiOutput, ForwardInput, ForwardOutput, };
+export type { IAnyIO, IIONode, IAudioInput, IAudioOutput, IMidiInput, IMidiOutput, IForwardInput, IForwardOutput, IAnyInput, IAnyOutput, IIOSerialize, AnyInput, AnyOuput, };

package/dist/build/core/Module/MonoModule.d.ts

@@ -0,0 +1,67 @@
+import { InputNode } from "tone";
+import { IOCollection, AudioInput, AudioOutput, MidiInput, IMidiInput, IAudioInput, IAudioOutput, MidiOutput, IMidiOutput } from "../IO";
+import { MidiEvent } from "../../core/midi";
+import { AudioModule } from "./index";
+import Note from "../../core/Note";
+import { AtLeast } from "../../types";
+export interface Startable {
+    start(time: number): void;
+    stop(time: number): void;
+}
+export interface Connectable {
+    connect: (inputNode: InputNode) => void;
+    disconnect: (inputNode?: InputNode) => void;
+    dispose: () => void;
+}
+export interface Triggerable {
+    triggerAttack: (note: Note, triggeredAt: number) => void;
+    triggerRelease: (note: Note, triggeredAt: number) => void;
+}
+export interface ModuleInterface<PropsInterface> {
+    id: string;
+    name: string;
+    props: PropsInterface;
+    voiceNo?: number;
+}
+export declare class DummnyInternalModule implements Connectable {
+    connect(): void;
+    disconnect(): void;
+    dispose(): void;
+}
+declare abstract class Module<InternalModule extends Connectable, PropsInterface> implements ModuleInterface<PropsInterface> {
+    static readonly moduleName: string;
+    readonly id: string;
+    name: string;
+    internalModule: InternalModule;
+    inputs: IOCollection<AudioInput | MidiInput>;
+    outputs: IOCollection<AudioOutput | MidiOutput>;
+    readonly voiceNo?: number;
+    updatedAt: Date;
+    _props: PropsInterface;
+    constructor(internalModule: InternalModule, props: AtLeast<ModuleInterface<PropsInterface>, "name">);
+    set props(value: PropsInterface);
+    get props(): PropsInterface;
+    plug(audioModule: AudioModule, from: string, to: string): void;
+    unPlugAll(): void;
+    dispose(): void;
+    triggerAttack: (note: Note, triggeredAt: number) => void;
+    triggerRelease: (note: Note, triggeredAt: number) => void;
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    private triggerer;
+    serialize(): {
+        id: string;
+        name: string;
+        type: string;
+        props: PropsInterface;
+        inputs: import("../IO").IIOSerialize[];
+        outputs: import("../IO").IIOSerialize[];
+    };
+    protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
+    protected registerAudioInput(props: Omit<IAudioInput, "ioType">): AudioInput;
+    protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput;
+    protected registerAudioOutput(props: Omit<IAudioOutput, "ioType">): AudioOutput;
+    protected registerBasicOutputs(): void;
+    protected registerBasicInputs(): void;
+    protected registerDefaultMidiInput(): void;
+}
+export default Module;

package/dist/build/core/Module/PolyModule.d.ts

@@ -0,0 +1,57 @@
+import { MidiEvent } from "../midi";
+import Module, { Connectable } from "./MonoModule";
+import { IOCollection, ForwardInput, ForwardOutput, IMidiInput, IMidiOutput, IForwardInput, IForwardOutput, MidiOutput, MidiInput } from "../IO";
+import { AudioModule } from "./index";
+interface PolyModuleInterface<MonoAudioModule, PropsInterface> {
+    id?: string;
+    name: string;
+    child: new (params: {
+        id?: string;
+        name: string;
+        props: PropsInterface;
+    }) => MonoAudioModule;
+    props: PropsInterface;
+}
+export default abstract class PolyModule<MonoAudioModule extends Module<Connectable, PropsInterface>, PropsInterface> {
+    static readonly moduleName: string;
+    readonly id: string;
+    readonly child: new (params: {
+        id?: string;
+        name: string;
+        props: PropsInterface;
+    }) => MonoAudioModule;
+    _name: string;
+    audioModules: MonoAudioModule[];
+    inputs: IOCollection<ForwardInput | MidiInput>;
+    outputs: IOCollection<ForwardOutput | MidiOutput>;
+    private _numberOfVoices;
+    constructor(params: PolyModuleInterface<MonoAudioModule, PropsInterface>);
+    get name(): string;
+    set name(value: string);
+    get props(): PropsInterface;
+    set props(value: PropsInterface);
+    get numberOfVoices(): number;
+    set numberOfVoices(value: number);
+    plug(audioModule: AudioModule, from: string, to: string): void;
+    unPlugAll(): void;
+    dispose(): void;
+    onMidiEvent: (midiEvent: MidiEvent) => void;
+    serialize(): {
+        id: string;
+        type: string;
+        inputs: import("../IO").IIOSerialize[];
+        outputs: import("../IO").IIOSerialize[];
+        name: string;
+        props: PropsInterface;
+    };
+    protected find(callback: (audioModule: MonoAudioModule) => boolean): MonoAudioModule;
+    protected findVoice(voiceNo: number): MonoAudioModule | undefined;
+    protected registerInput(props: Omit<IForwardInput, "ioType">): ForwardInput;
+    protected registerOutput(props: Omit<IForwardOutput, "ioType">): ForwardOutput;
+    protected registerMidiInput(props: Omit<IMidiInput, "ioType">): MidiInput;
+    protected registerMidiOutput(props: Omit<IMidiOutput, "ioType">): MidiOutput;
+    protected registerBasicOutputs(): void;
+    protected registerBasicInputs(): void;
+    private adjustNumberOfModules;
+}
+export {};

package/dist/build/core/Module/index.d.ts

@@ -0,0 +1,6 @@
+import Module, { Connectable } from "./MonoModule";
+import PolyModule from "./PolyModule";
+export { default, DummnyInternalModule } from "./MonoModule";
+export { default as PolyModule } from "./PolyModule";
+export type { ModuleInterface, Connectable, Triggerable, Startable, } from "./MonoModule";
+export type AudioModule = Module<Connectable, any> | PolyModule<Module<Connectable, any>, any>;

package/{build → dist/build/core}/Note/index.d.ts

@@ -15,6 +15,9 @@ export default class Note {
     static notes(octave?: number): Note[];
     get isSemi(): boolean;
     get fullName(): string;
+    midiData(noteOn?: boolean): Uint8Array;
+    get midiNumber(): number;
+    get noteIndex(): number;
     adjustFrequency(range?: number, coarse?: number): number;
     valueOf(): string;
     serialize(): INote;

package/{build → dist/build/core/midi}/MidiDevice.d.ts

@@ -4,7 +4,7 @@ export interface MidiDeviceInterface {
     name: string;
     state: string;
 }
-export declare type EventListerCallback = (event: MidiEvent) => void;
+export type EventListerCallback = (event: MidiEvent) => void;
 export default class MidiDevice implements MidiDeviceInterface {
     id: string;
     name: string;

package/dist/build/core/midi/MidiEvent.d.ts

@@ -0,0 +1,21 @@
+import { ISequence } from "../../modules";
+import Note, { INote } from "../Note";
+export type MidiEventType = "noteOn" | "noteOff" | "cc";
+export default class MidiEvent {
+    note: Note;
+    voiceNo?: number;
+    readonly triggeredAt: number;
+    _type: MidiEventType;
+    private data;
+    private event;
+    static fromSequence(sequence: ISequence, triggeredAt: number): MidiEvent[];
+    static fromNote(noteName: string | Note | INote, noteOn?: boolean, triggeredAt?: number): MidiEvent;
+    static fromCC(cc: number, value: number, triggeredAt?: number): MidiEvent;
+    constructor(event: MIDIMessageEvent, triggeredAt?: number);
+    get statusByte(): number;
+    get firstData(): number;
+    get secondData(): number;
+    get type(): MidiEventType;
+    get isNote(): boolean;
+    defineNotes(): void;
+}

package/dist/build/core/midi/index.d.ts

@@ -0,0 +1,5 @@
+export { default as MidiEvent } from "./MidiEvent";
+export { default as MidiDevice } from "./MidiDevice";
+export { default as MidiDeviceManager } from "./MidiDeviceManager";
+export type { MidiDeviceInterface } from "./MidiDevice";
+export type { MidiEventType } from "./MidiEvent";

package/dist/build/index.d.ts

@@ -0,0 +1,9 @@
+export { default } from "./Engine";
+export { MidiDevice, MidiDeviceManager } from "./core/midi";
+export { default as Note } from "./core/Note";
+export type { MidiDeviceInterface } from "./core/midi";
+export type { INote } from "./core/Note";
+export type { ModuleInterface, AudioModule } from "./core/Module";
+export type { ISequence } from "./modules";
+export type { RouteInterface, RouteProps } from "./routes";
+export type { IIOSerialize as IOProps } from "./core/IO";

package/{build/Module → dist/build/modules}/BitCrusher.d.ts

@@ -5,7 +5,11 @@ interface BitCrusherInterface extends EffectInterface {
 }
 export default class BitCrusher extends Effect<InternalBitCrasher, BitCrusherInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<BitCrusherInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<BitCrusherInterface>;
+    });
     get bits(): number;
     set bits(value: number);
 }

package/{build/Module → dist/build/modules}/Delay.d.ts

@@ -6,7 +6,11 @@ interface DelayInterface extends EffectInterface {
 }
 export default class Delay extends Effect<FeedbackDelay, DelayInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<DelayInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<DelayInterface>;
+    });
     get delayTime(): number;
     set delayTime(value: number);
     get feedback(): number;

package/{build/Module → dist/build/modules}/Distortion.d.ts

@@ -5,7 +5,11 @@ interface DistortionInterface extends EffectInterface {
 }
 export default class Distortion extends Effect<InternalDistortion, DistortionInterface> {
     static moduleName: string;
-    constructor(name: string, props: Partial<DistortionInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<DistortionInterface>;
+    });
     get drive(): number;
     set drive(value: number);
 }

package/{build/Module → dist/build/modules}/Effect.d.ts

@@ -1,5 +1,5 @@
 import { Signal } from "tone";
-import Module, { Connectable } from "./Base";
+import Module, { Connectable } from "../core/Module";
 interface EffectLike extends Connectable {
     wet: Signal<"normalRange">;
 }
@@ -7,7 +7,12 @@ export interface EffectInterface {
     wet: number;
 }
 export default abstract class Effect<InternalEffect extends EffectLike, ModuleInterface extends EffectInterface> extends Module<InternalEffect, ModuleInterface> {
-    constructor(name: string, internalModule: InternalEffect, props: Partial<ModuleInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        internalModule: InternalEffect;
+        props: Partial<ModuleInterface>;
+    });
     get wet(): number;
     set wet(value: number);
 }

package/{build/Module → dist/build/modules}/Envelope/AmpEnvelope.d.ts

@@ -1,10 +1,18 @@
 import { AmplitudeEnvelope } from "tone";
 import Base, { EnvelopeInterface, PolyBase } from "./Base";
 declare class MonoAmpEnvelope extends Base<AmplitudeEnvelope> {
-    constructor(name: string, props: EnvelopeInterface);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: EnvelopeInterface;
+    });
 }
 export default class AmpEnvelope extends PolyBase<MonoAmpEnvelope> {
     static moduleName: string;
-    constructor(name: string, props: Partial<EnvelopeInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<EnvelopeInterface>;
+    });
 }
 export {};

package/{build/Module → dist/build/modules}/Envelope/Base.d.ts

@@ -1,24 +1,27 @@
 import { Envelope as Env } from "tone";
-import Module, { Connectable, Triggerable, Voicable } from "../Base";
-import PolyModule from "../PolyModule";
-import Note from "../../Note";
+import Module, { PolyModule, Connectable, Triggerable } from "../../core/Module";
+import Note from "../../core/Note";
 export declare const enum EnvelopeStages {
     Attack = "attack",
     Decay = "decay",
     Sustain = "sustain",
     Release = "release"
 }
-export interface EnvelopeInterface extends Voicable {
+export interface EnvelopeInterface {
     attack: number;
     decay: number;
     sustain: number;
     release: number;
-    voiceNo?: number;
 }
 export default abstract class EnvelopeModule<EnvelopeLike extends Env> extends Module<EnvelopeLike, EnvelopeInterface> implements Triggerable {
     activeNote?: string;
     triggeredAt: number;
-    constructor(name: string, internalModule: EnvelopeLike, props: EnvelopeInterface);
+    constructor(params: {
+        id?: string;
+        name: string;
+        internalModule: EnvelopeLike;
+        props: EnvelopeInterface;
+    });
     get attack(): number;
     set attack(value: number);
     get decay(): number;
@@ -33,15 +36,31 @@ export default abstract class EnvelopeModule<EnvelopeLike extends Env> extends M
     private maxTime;
     private minTime;
 }
-export declare abstract class PolyBase<EnvelopeModule extends Module<Connectable, any>> extends PolyModule<EnvelopeModule, EnvelopeInterface> {
-    constructor(name: string, child: new (name: string, props: EnvelopeInterface) => EnvelopeModule, props: Partial<EnvelopeInterface>);
-    private registerInputs;
+export declare abstract class PolyBase<EnvelopeModule extends Module<Connectable, EnvelopeInterface>> extends PolyModule<EnvelopeModule, EnvelopeInterface> {
+    constructor(params: {
+        id?: string;
+        name: string;
+        child: new (params: {
+            id?: string;
+            name: string;
+            props: EnvelopeInterface;
+        }) => EnvelopeModule;
+        props: Partial<EnvelopeInterface>;
+    });
 }
 declare class MonoEnvelope extends EnvelopeModule<Env> {
-    constructor(name: string, props: EnvelopeInterface);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: EnvelopeInterface;
+    });
 }
 export declare class Envelope extends PolyBase<MonoEnvelope> {
     static moduleName: string;
-    constructor(name: string, props: Partial<EnvelopeInterface>);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<EnvelopeInterface>;
+    });
 }
 export {};

package/{build/Module → dist/build/modules}/Envelope/FreqEnvelope.d.ts

@@ -5,7 +5,11 @@ export declare class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
     private _frequency;
     private _amount;
     filter: Filter;
-    constructor(name: string, props: EnvelopeInterface);
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: EnvelopeInterface;
+    });
     get frequency(): number;
     set frequency(value: number);
     get amount(): number;
@@ -13,6 +17,9 @@ export declare class MonoFreqEnvelope extends Base<FrequencyEnvelope> {
 }
 export default class FreqEnvelope extends PolyBase<MonoFreqEnvelope> {
     static moduleName: string;
-    constructor(name: string, props: Partial<EnvelopeInterface>);
-    protected registerOutputs(): void;
+    constructor(params: {
+        id?: string;
+        name: string;
+        props: Partial<EnvelopeInterface>;
+    });
 }