@blibliki/engine 0.5.2 → 0.9.0

package/src/modules/LegacyEnvelope.ts

@@ -0,0 +1,146 @@
+import { ContextTime } from "@blibliki/transport";
+import { Context } from "@blibliki/utils";
+import { GainNode } from "@blibliki/utils/web-audio-api";
+import { Module } from "@/core";
+import Note from "@/core/Note";
+import { IModuleConstructor } from "@/core/module/Module";
+import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
+import { ModulePropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IEnvelopeProps = {
+  attack: number;
+  decay: number;
+  sustain: number;
+  release: number;
+};
+
+const DEFAULT_PROPS: IEnvelopeProps = {
+  attack: 0.01,
+  decay: 0.1,
+  sustain: 0.7,
+  release: 0.3,
+};
+
+export const envelopePropSchema: ModulePropSchema<IEnvelopeProps> = {
+  attack: {
+    kind: "number",
+    min: 0.001,
+    max: 10,
+    step: 0.001,
+    exp: 3,
+    label: "Attack",
+  },
+  decay: {
+    kind: "number",
+    min: 0.001,
+    max: 10,
+    step: 0.001,
+    exp: 3,
+    label: "Decay",
+  },
+  sustain: {
+    kind: "number",
+    min: 0,
+    max: 1,
+    step: 0.01,
+    label: "Sustain",
+  },
+  release: {
+    kind: "number",
+    min: 0.001,
+    max: 10,
+    step: 0.001,
+    exp: 3,
+    label: "Release",
+  },
+};
+
+// Constants for safe audio parameter automation
+const MIN_GAIN = 0.00001;
+
+class MonoEnvelope extends Module<ModuleType.LegacyEnvelope> {
+  declare audioNode: GainNode;
+
+  constructor(
+    engineId: string,
+    params: ICreateModule<ModuleType.LegacyEnvelope>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const audioNodeConstructor = (context: Context) => {
+      const audioNode = new GainNode(context.audioContext);
+      audioNode.gain.value = 0;
+      return audioNode;
+    };
+
+    super(engineId, {
+      ...params,
+      props,
+      audioNodeConstructor,
+    });
+
+    this.registerDefaultIOs();
+  }
+
+  triggerAttack(note: Note, triggeredAt: ContextTime) {
+    super.triggerAttack(note, triggeredAt);
+
+    const { attack, decay, sustain } = this.props;
+    const gain = this.audioNode.gain;
+
+    // Exponential reset to avoid clicks when retriggering (production-style)
+    gain.cancelAndHoldAtTime(triggeredAt);
+    const resetTimeConstant = 0.002; // 2ms time constant for exponential decay
+    const resetDuration = resetTimeConstant * 5; // ~10ms total (5 time constants ≈ 99% complete)
+    gain.setTargetAtTime(MIN_GAIN, triggeredAt, resetTimeConstant);
+
+    // Attack phase: linear ramp to peak
+    const attackStartTime = triggeredAt + resetDuration;
+    const attackEndTime = attackStartTime + attack;
+    gain.setValueAtTime(MIN_GAIN, attackStartTime); // Ensure we start from MIN_GAIN
+    gain.linearRampToValueAtTime(1.0, attackEndTime);
+
+    // Decay phase: exponential ramp to sustain level
+    if (sustain < 1) {
+      const decayEndTime = attackEndTime + decay;
+      // exponentialRampToValueAtTime cannot reach 0, use MIN_GAIN instead
+      const sustainValue = sustain > 0 ? sustain : MIN_GAIN;
+      gain.exponentialRampToValueAtTime(sustainValue, decayEndTime);
+    }
+  }
+
+  triggerRelease(note: Note, triggeredAt: ContextTime) {
+    super.triggerRelease(note, triggeredAt);
+
+    // Only release if this is the last active note
+    if (this.activeNotes.length > 0) return;
+
+    const { release } = this.props;
+    const gain = this.audioNode.gain;
+
+    // Release phase: exponential fade to silence (analog-style)
+    gain.cancelAndHoldAtTime(triggeredAt);
+    gain.setTargetAtTime(MIN_GAIN, triggeredAt, release);
+  }
+}
+
+export default class Envelope extends PolyModule<ModuleType.LegacyEnvelope> {
+  constructor(
+    engineId: string,
+    params: IPolyModuleConstructor<ModuleType.LegacyEnvelope>,
+  ) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+    const monoModuleConstructor = (
+      engineId: string,
+      params: IModuleConstructor<ModuleType.LegacyEnvelope>,
+    ) => Module.create(MonoEnvelope, engineId, params);
+
+    super(engineId, {
+      ...params,
+      props,
+      monoModuleConstructor,
+    });
+
+    this.registerDefaultIOs();
+  }
+}

package/src/modules/{MidiSelector.ts → MidiInput.ts}

@@ -1,16 +1,22 @@
-import { IModule, Module, MidiOutput, SetterHooks, MidiDevice } from "@/core";
+import {
+  IModule,
+  Module,
+  MidiOutput,
+  SetterHooks,
+  MidiInputDevice,
+} from "@/core";
 import ComputerKeyboardInput from "@/core/midi/ComputerKeyboardDevice";
 import MidiEvent from "@/core/midi/MidiEvent";
 import { ModulePropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
-export type IMidiSelector = IModule<ModuleType.MidiSelector>;
-export type IMidiSelectorProps = {
+export type IMidiInput = IModule<ModuleType.MidiInput>;
+export type IMidiInputProps = {
   selectedId: string | undefined | null;
   selectedName: string | undefined | null;
 };
 
-export const midiSelectorPropSchema: ModulePropSchema<IMidiSelectorProps> = {
+export const midiInputPropSchema: ModulePropSchema<IMidiInputProps> = {
   selectedId: {
     kind: "string",
     label: "Midi device ID",
@@ -21,23 +27,20 @@ export const midiSelectorPropSchema: ModulePropSchema<IMidiSelectorProps> = {
   },
 };
 
-const DEFAULT_PROPS: IMidiSelectorProps = {
+const DEFAULT_PROPS: IMidiInputProps = {
   selectedId: undefined,
   selectedName: undefined,
 };
 
-export default class MidiSelector
-  extends Module<ModuleType.MidiSelector>
-  implements Pick<SetterHooks<IMidiSelectorProps>, "onSetSelectedId">
+export default class MidiInput
+  extends Module<ModuleType.MidiInput>
+  implements Pick<SetterHooks<IMidiInputProps>, "onSetSelectedId">
 {
   declare audioNode: undefined;
   midiOutput!: MidiOutput;
   _forwardMidiEvent?: (midiEvent: MidiEvent) => void;
 
-  constructor(
-    engineId: string,
-    params: ICreateModule<ModuleType.MidiSelector>,
-  ) {
+  constructor(engineId: string, params: ICreateModule<ModuleType.MidiInput>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
 
     super(engineId, {
@@ -51,14 +54,16 @@ export default class MidiSelector
     // 3. By fuzzy name match (for cross-platform compatibility)
     let midiDevice =
       this.props.selectedId &&
-      this.engine.findMidiDevice(this.props.selectedId);
+      this.engine.findMidiInputDevice(this.props.selectedId);
 
     if (!midiDevice && this.props.selectedName) {
-      midiDevice = this.engine.findMidiDeviceByName(this.props.selectedName);
+      midiDevice = this.engine.findMidiInputDeviceByName(
+        this.props.selectedName,
+      );
 
       // If exact name match fails, try fuzzy matching
       if (!midiDevice) {
-        const fuzzyMatch = this.engine.findMidiDeviceByFuzzyName(
+        const fuzzyMatch = this.engine.findMidiInputDeviceByFuzzyName(
           this.props.selectedName,
           0.6, // 60% similarity threshold
         );
@@ -79,13 +84,13 @@ export default class MidiSelector
     this.registerOutputs();
   }
 
-  onSetSelectedId: SetterHooks<IMidiSelectorProps>["onSetSelectedId"] = (
+  onSetSelectedId: SetterHooks<IMidiInputProps>["onSetSelectedId"] = (
     value,
   ) => {
     this.removeEventListener();
     if (!value) return value;
 
-    const midiDevice = this.engine.findMidiDevice(value);
+    const midiDevice = this.engine.findMidiInputDevice(value);
     if (!midiDevice) return value;
 
     if (this.props.selectedName !== midiDevice.name) {
@@ -107,14 +112,16 @@ export default class MidiSelector
     return this._forwardMidiEvent;
   }
 
-  private addEventListener(midiDevice: MidiDevice | ComputerKeyboardInput) {
+  private addEventListener(
+    midiDevice: MidiInputDevice | ComputerKeyboardInput,
+  ) {
     midiDevice.addEventListener(this.forwardMidiEvent);
   }
 
   private removeEventListener() {
     if (!this.props.selectedId) return;
 
-    const midiDevice = this.engine.findMidiDevice(this.props.selectedId);
+    const midiDevice = this.engine.findMidiInputDevice(this.props.selectedId);
     midiDevice?.removeEventListener(this.forwardMidiEvent);
   }
 

package/src/modules/MidiMapper.ts

@@ -1,5 +1,5 @@
 import { ContextTime } from "@blibliki/transport";
-import { IModule, MidiEvent, Module, SetterHooks } from "@/core";
+import { IModule, MidiEvent, MidiOutput, Module, SetterHooks } from "@/core";
 import { ModulePropSchema, NumberProp, PropSchema } from "@/core/schema";
 import { ICreateModule, moduleSchemas, ModuleType } from ".";
 
@@ -26,6 +26,7 @@ export enum MidiMappingMode {
 
 export type MidiMapping<T extends ModuleType> = {
   cc?: number;
+  value?: number;
   moduleId?: string;
   moduleType?: T;
   propName?: string;
@@ -102,6 +103,7 @@ export default class MidiMapper
   implements MidiMapperSetterHooks
 {
   declare audioNode: undefined;
+  private _midiOut: MidiOutput; // Will be used to send CC values on page change
 
   constructor(engineId: string, params: ICreateModule<ModuleType.MidiMapper>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
@@ -115,10 +117,31 @@ export default class MidiMapper
       name: "midi in",
       onMidiEvent: this.onMidiEvent,
     });
+
+    this._midiOut = this.registerMidiOutput({
+      name: "midi out",
+    });
   }
 
   onSetActivePage: MidiMapperSetterHooks["onSetActivePage"] = (value) => {
-    return Math.max(Math.min(value, this.props.pages.length - 1), 0);
+    const activePage = Math.max(
+      Math.min(value, this.props.pages.length - 1),
+      0,
+    );
+
+    const newPage = this.props.pages[activePage];
+
+    // Send stored CC values to MIDI output when changing pages
+    const now = this.context.currentTime;
+    newPage?.mappings.forEach((mapping) => {
+      if (mapping.cc !== undefined && mapping.value !== undefined) {
+        // Create CC MIDI event and send it
+        const midiEvent = MidiEvent.fromCC(mapping.cc, mapping.value, now);
+        this._midiOut.onMidiEvent(midiEvent);
+      }
+    });
+
+    return activePage;
   };
 
   handleCC = (event: MidiEvent, triggeredAt: ContextTime) => {
@@ -127,12 +150,44 @@ export default class MidiMapper
     const activePage = this.props.pages[this.props.activePage];
     if (!activePage) return;
 
-    [
+    const matchingMappings = [
       ...this.props.globalMappings.filter((m) => m.cc === event.cc),
       ...activePage.mappings.filter((m) => m.cc === event.cc),
-    ].forEach((mapping) => {
+    ];
+
+    // Forward all matching mappings
+    matchingMappings.forEach((mapping) => {
       this.forwardMapping(event, mapping, triggeredAt);
     });
+
+    // Update mapping values if we have matching CCs
+    if (matchingMappings.length > 0 && event.ccValue !== undefined) {
+      const updatedGlobalMappings = this.props.globalMappings.map((mapping) => {
+        if (mapping.cc === event.cc) {
+          return { ...mapping, value: event.ccValue };
+        }
+        return mapping;
+      });
+
+      const updatedPageMappings = activePage.mappings.map((mapping) => {
+        if (mapping.cc === event.cc) {
+          return { ...mapping, value: event.ccValue };
+        }
+        return mapping;
+      });
+
+      const updatedPages = this.props.pages.map((page, index) =>
+        index === this.props.activePage
+          ? { ...page, mappings: updatedPageMappings }
+          : page,
+      );
+
+      this.props = {
+        pages: updatedPages,
+        globalMappings: updatedGlobalMappings,
+      };
+      this.triggerPropsUpdate();
+    }
   };
 
   forwardMapping = (

package/src/modules/MidiOutput.ts

@@ -0,0 +1,121 @@
+import {
+  IModule,
+  Module,
+  MidiInput,
+  SetterHooks,
+  MidiOutputDevice,
+} from "@/core";
+import MidiEvent from "@/core/midi/MidiEvent";
+import { ModulePropSchema } from "@/core/schema";
+import { ICreateModule, ModuleType } from ".";
+
+export type IMidiOutput = IModule<ModuleType.MidiOutput>;
+export type IMidiOutputProps = {
+  selectedId: string | undefined | null;
+  selectedName: string | undefined | null;
+};
+
+export const midiOutputPropSchema: ModulePropSchema<IMidiOutputProps> = {
+  selectedId: {
+    kind: "string",
+    label: "Midi device ID",
+  },
+  selectedName: {
+    kind: "string",
+    label: "Midi device name",
+  },
+};
+
+const DEFAULT_PROPS: IMidiOutputProps = {
+  selectedId: undefined,
+  selectedName: undefined,
+};
+
+export default class MidiOutput
+  extends Module<ModuleType.MidiOutput>
+  implements Pick<SetterHooks<IMidiOutputProps>, "onSetSelectedId">
+{
+  declare audioNode: undefined;
+  midiInput!: MidiInput;
+  private currentDevice?: MidiOutputDevice;
+
+  constructor(engineId: string, params: ICreateModule<ModuleType.MidiOutput>) {
+    const props = { ...DEFAULT_PROPS, ...params.props };
+
+    super(engineId, {
+      ...params,
+      props,
+    });
+
+    // Try to find device in order of preference:
+    // 1. By exact ID match
+    // 2. By exact name match
+    // 3. By fuzzy name match (for cross-platform compatibility)
+    let midiDevice =
+      this.props.selectedId &&
+      this.engine.findMidiOutputDevice(this.props.selectedId);
+
+    if (!midiDevice && this.props.selectedName) {
+      midiDevice = this.engine.findMidiOutputDeviceByName(
+        this.props.selectedName,
+      );
+
+      // If exact name match fails, try fuzzy matching
+      if (!midiDevice) {
+        const fuzzyMatch = this.engine.findMidiOutputDeviceByFuzzyName(
+          this.props.selectedName,
+          0.6, // 60% similarity threshold
+        );
+
+        if (fuzzyMatch) {
+          midiDevice = fuzzyMatch.device;
+          console.log(
+            `MIDI device fuzzy matched: "${this.props.selectedName}" -> "${midiDevice.name}" (confidence: ${Math.round(fuzzyMatch.score * 100)}%)`,
+          );
+        }
+      }
+    }
+
+    if (midiDevice) {
+      this.currentDevice = midiDevice;
+    }
+
+    this.registerInputs();
+  }
+
+  onSetSelectedId: SetterHooks<IMidiOutputProps>["onSetSelectedId"] = (
+    value,
+  ) => {
+    if (!value) {
+      this.currentDevice = undefined;
+      return value;
+    }
+
+    const midiDevice = this.engine.findMidiOutputDevice(value);
+    if (!midiDevice) return value;
+
+    if (this.props.selectedName !== midiDevice.name) {
+      this.props = { selectedName: midiDevice.name };
+      this.triggerPropsUpdate();
+    }
+
+    this.currentDevice = midiDevice;
+
+    return value;
+  };
+
+  onMidiEvent = (midiEvent: MidiEvent) => {
+    if (!this.currentDevice) return;
+
+    // Send raw MIDI data to hardware
+    const rawData = midiEvent.rawMessage.data;
+    this.currentDevice.send(rawData);
+  };
+
+  private registerInputs() {
+    this.midiInput = this.registerMidiInput({
+      name: "midi in",
+      onMidiEvent: this.onMidiEvent,
+    });
+  }
+}