@blibliki/engine 0.5.1 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.5.1",
+  "version": "0.9.0",
   "type": "module",
   "exports": {
     ".": {
@@ -15,15 +15,15 @@
     "dist"
   ],
   "devDependencies": {
-    "@types/audioworklet": "0.0.92",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "4.0.15"
+    "@types/audioworklet": "0.0.93",
+    "vite-tsconfig-paths": "6.0.5",
+    "vitest": "4.0.18"
   },
   "dependencies": {
     "@julusian/midi": "^3.6.1",
-    "es-toolkit": "^1.41.0",
-    "@blibliki/transport": "^0.5.1",
-    "@blibliki/utils": "^0.5.1"
+    "es-toolkit": "1.44.0",
+    "@blibliki/transport": "^0.9.0",
+    "@blibliki/utils": "^0.9.0"
   },
   "scripts": {
     "build": "tsup",

package/src/Engine.ts

@@ -1,11 +1,4 @@
-import {
-  BPM,
-  ContextTime,
-  Ticks,
-  TimeSignature,
-  Transport,
-  TransportEvent,
-} from "@blibliki/transport";
+import { BPM, Ticks, TimeSignature, Transport } from "@blibliki/transport";
 import {
   assertDefined,
   Context,
@@ -26,6 +19,7 @@ import {
   ModuleParams,
   ModuleType,
   ModuleTypeToModuleMapping,
+  ModuleTypeToStateMapping,
   createModule,
 } from "@/modules";
 import {
@@ -63,7 +57,7 @@ export class Engine {
   context: Context;
   isInitialized = false;
   routes: Routes;
-  transport: Transport<TransportEvent>;
+  transport: Transport;
   modules: Map<
     string,
     ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]
@@ -107,20 +101,8 @@ export class Engine {
 
     this.context = context;
     this.transport = new Transport(this.context, {
-      generator: (_start: Ticks, _end: Ticks) => {
-        return [] as TransportEvent[];
-      },
-      consumer: (_event: TransportEvent) => {
-        return;
-      },
-      onJump: (_ticks: Ticks) => {
-        return;
-      },
       onStart: this.onStart,
       onStop: this.onStop,
-      silence: (_actionAt: ContextTime) => {
-        return;
-      },
     });
     this.routes = new Routes(this);
     this.modules = new Map();
@@ -197,16 +179,19 @@ export class Engine {
 
   async start() {
     await this.resume();
-    this.transport.start();
+    const actionAt = this.context.currentTime;
+    this.transport.start(actionAt);
   }
 
   stop() {
-    this.transport.stop();
-    this.transport.reset();
+    const actionAt = this.context.currentTime;
+    this.transport.stop(actionAt);
+    this.transport.reset(actionAt);
   }
 
   pause() {
-    this.transport.stop();
+    const actionAt = this.context.currentTime;
+    this.transport.stop(actionAt);
   }
 
   get bpm() {
@@ -273,16 +258,44 @@ export class Engine {
     return this.midiDeviceManager.findByFuzzyName(name, threshold);
   }
 
+  findMidiInputDevice(id: string) {
+    return this.midiDeviceManager.findInput(id);
+  }
+
+  findMidiInputDeviceByName(name: string) {
+    return this.midiDeviceManager.findInputByName(name);
+  }
+
+  findMidiInputDeviceByFuzzyName(name: string, threshold?: number) {
+    return this.midiDeviceManager.findInputByFuzzyName(name, threshold);
+  }
+
+  findMidiOutputDevice(id: string) {
+    return this.midiDeviceManager.findOutput(id);
+  }
+
+  findMidiOutputDeviceByName(name: string) {
+    return this.midiDeviceManager.findOutputByName(name);
+  }
+
+  findMidiOutputDeviceByFuzzyName(name: string, threshold?: number) {
+    return this.midiDeviceManager.findOutputByFuzzyName(name, threshold);
+  }
+
   onPropsUpdate(
     callback: <T extends ModuleType>(
-      params: IModule<T> | IPolyModule<T>,
+      params: (IModule<T> | IPolyModule<T>) & {
+        state?: ModuleTypeToStateMapping[T];
+      },
     ) => void,
   ) {
     this.propsUpdateCallbacks.push(callback);
   }
 
   _triggerPropsUpdate<T extends ModuleType>(
-    params: IModule<T> | IPolyModule<T>,
+    params: (IModule<T> | IPolyModule<T>) & {
+      state?: ModuleTypeToStateMapping[T];
+    },
   ) {
     this.propsUpdateCallbacks.forEach((callback) => {
       callback(params);
@@ -301,14 +314,18 @@ export class Engine {
   }
 
   // actionAt is context time
-  private onStart = (actionAt: ContextTime) => {
+  private onStart = (ticks: Ticks) => {
+    const actionAt = this.transport.getContextTimeAtTicks(ticks);
+
     this.modules.forEach((module) => {
       module.start(actionAt);
     });
   };
 
   // actionAt is context time
-  private onStop = (actionAt: ContextTime) => {
+  private onStop = (ticks: Ticks) => {
+    const actionAt = this.transport.getContextTimeAtTicks(ticks);
+
     this.modules.forEach((module) => {
       module.stop(actionAt);
     });

package/src/core/index.ts

@@ -5,6 +5,7 @@ export type {
   IPolyModuleSerialize,
   IAnyModuleSerialize,
   SetterHooks,
+  StateSetterHooks,
 } from "./module";
 
 export type IAnyAudioContext = AudioContext | OfflineAudioContext;
@@ -13,8 +14,16 @@ export { Routes } from "./Route";
 export type { IRoute } from "./Route";
 
 export { default as MidiDeviceManager } from "./midi/MidiDeviceManager";
-export { default as MidiDevice, MidiPortState } from "./midi/MidiDevice";
-export type { IMidiDevice } from "./midi/MidiDevice";
+export {
+  default as BaseMidiDevice,
+  MidiPortState,
+} from "./midi/BaseMidiDevice";
+export type { IMidiDevice } from "./midi/BaseMidiDevice";
+export { default as MidiInputDevice } from "./midi/MidiInputDevice";
+export type { IMidiInput, EventListerCallback } from "./midi/MidiInputDevice";
+export { default as MidiOutputDevice } from "./midi/MidiOutputDevice";
+// Legacy export for backwards compatibility
+export { default as MidiDevice } from "./midi/MidiInputDevice";
 export { default as MidiEvent, MidiEventType } from "./midi/MidiEvent";
 export {
   normalizeDeviceName,

package/src/core/midi/BaseMidiDevice.ts

@@ -0,0 +1,47 @@
+import { IMidiPort } from "./adapters";
+
+export enum MidiPortState {
+  connected = "connected",
+  disconnected = "disconnected",
+}
+
+export type IMidiDevice = {
+  id: string;
+  name: string;
+  state: MidiPortState;
+};
+
+export default abstract class BaseMidiDevice<
+  T extends IMidiPort,
+> implements IMidiDevice {
+  protected midiPort: T;
+
+  constructor(props: T) {
+    this.midiPort = props;
+    this.connect();
+  }
+
+  abstract connect(): void;
+
+  abstract disconnect(): void;
+
+  get id() {
+    return this.midiPort.id;
+  }
+
+  get name() {
+    return this.midiPort.name;
+  }
+
+  get type() {
+    return this.midiPort.type;
+  }
+
+  get state() {
+    return this.midiPort.state as MidiPortState;
+  }
+
+  serialize() {
+    return { id: this.id, name: this.name, type: this.type, state: this.state };
+  }
+}

package/src/core/midi/ComputerKeyboardDevice.ts

@@ -1,7 +1,8 @@
 import { Context } from "@blibliki/utils";
 import Note from "../Note";
-import { EventListerCallback, IMidiInput, MidiPortState } from "./MidiDevice";
+import { MidiPortState } from "./BaseMidiDevice";
 import MidiEvent from "./MidiEvent";
+import { EventListerCallback, IMidiInput } from "./MidiInputDevice";
 
 const MAP_KEYS: Record<string, Note> = {
   a: new Note("C3"),

package/src/core/midi/MidiDeviceManager.ts

@@ -1,13 +1,15 @@
 import { Context } from "@blibliki/utils";
 import ComputerKeyboardDevice from "./ComputerKeyboardDevice";
-import MidiDevice from "./MidiDevice";
+import MidiInputDevice from "./MidiInputDevice";
+import MidiOutputDevice from "./MidiOutputDevice";
 import { createMidiAdapter, type IMidiAccess } from "./adapters";
 import { findBestMatch } from "./deviceMatcher";
 
-type ListenerCallback = (device: MidiDevice) => void;
+type ListenerCallback = (device: MidiInputDevice | MidiOutputDevice) => void;
 
 export default class MidiDeviceManager {
-  devices = new Map<string, MidiDevice | ComputerKeyboardDevice>();
+  inputDevices = new Map<string, MidiInputDevice | ComputerKeyboardDevice>();
+  outputDevices = new Map<string, MidiOutputDevice>();
   private initialized = false;
   private listeners: ListenerCallback[] = [];
   private context: Readonly<Context>;
@@ -26,12 +28,47 @@ export default class MidiDeviceManager {
     this.initialized = true;
   }
 
-  find(id: string): MidiDevice | ComputerKeyboardDevice | undefined {
-    return this.devices.get(id);
+  find(
+    id: string,
+  ): MidiInputDevice | ComputerKeyboardDevice | MidiOutputDevice | undefined {
+    return this.findInput(id) ?? this.findOutput(id);
   }
 
-  findByName(name: string): MidiDevice | ComputerKeyboardDevice | undefined {
-    return Array.from(this.devices.values()).find((d) => d.name === name);
+  findByName(
+    name: string,
+  ): MidiInputDevice | ComputerKeyboardDevice | MidiOutputDevice | undefined {
+    return this.findInputByName(name) ?? this.findOutputByName(name);
+  }
+
+  findByFuzzyName(
+    name: string,
+    threshold = 0.6,
+  ): MidiInputDevice | ComputerKeyboardDevice | MidiOutputDevice | undefined {
+    const input = this.findInputByFuzzyName(name, threshold);
+    const output = this.findOutputByFuzzyName(name, threshold);
+
+    if (!input) return output?.device;
+    if (!output) return input.device;
+
+    return input.score > output.score ? input.device : output.device;
+  }
+
+  findInput(id: string): MidiInputDevice | ComputerKeyboardDevice | undefined {
+    return this.inputDevices.get(id);
+  }
+
+  findInputByName(
+    name: string,
+  ): MidiInputDevice | ComputerKeyboardDevice | undefined {
+    return Array.from(this.inputDevices.values()).find((d) => d.name === name);
+  }
+
+  findOutput(id: string): MidiOutputDevice | undefined {
+    return this.outputDevices.get(id);
+  }
+
+  findOutputByName(name: string): MidiOutputDevice | undefined {
+    return Array.from(this.outputDevices.values()).find((d) => d.name === name);
   }
 
   /**
@@ -42,11 +79,30 @@ export default class MidiDeviceManager {
    * @param threshold - Minimum similarity score (0-1, default: 0.6)
    * @returns The best matching device and confidence score, or null
    */
-  findByFuzzyName(
+  findInputByFuzzyName(
     targetName: string,
     threshold = 0.6,
-  ): { device: MidiDevice | ComputerKeyboardDevice; score: number } | null {
-    const deviceEntries = Array.from(this.devices.values());
+  ): {
+    device: MidiInputDevice | ComputerKeyboardDevice;
+    score: number;
+  } | null {
+    const deviceEntries = Array.from(this.inputDevices.values());
+    const candidateNames = deviceEntries.map((d) => d.name);
+
+    const match = findBestMatch(targetName, candidateNames, threshold);
+
+    if (!match) return null;
+
+    const device = deviceEntries.find((d) => d.name === match.name);
+
+    return device ? { device, score: match.score } : null;
+  }
+
+  findOutputByFuzzyName(
+    targetName: string,
+    threshold = 0.6,
+  ): { device: MidiOutputDevice; score: number } | null {
+    const deviceEntries = Array.from(this.outputDevices.values());
     const candidateNames = deviceEntries.map((d) => d.name);
 
     const match = findBestMatch(targetName, candidateNames, threshold);
@@ -79,8 +135,17 @@ export default class MidiDeviceManager {
       }
 
       for (const input of this.midiAccess.inputs()) {
-        if (!this.devices.has(input.id)) {
-          this.devices.set(input.id, new MidiDevice(input, this.context));
+        if (!this.inputDevices.has(input.id)) {
+          this.inputDevices.set(
+            input.id,
+            new MidiInputDevice(input, this.context),
+          );
+        }
+      }
+
+      for (const output of this.midiAccess.outputs()) {
+        if (!this.outputDevices.has(output.id)) {
+          this.outputDevices.set(output.id, new MidiOutputDevice(output));
         }
       }
     } catch (err) {
@@ -92,7 +157,7 @@ export default class MidiDeviceManager {
     if (typeof document === "undefined") return;
 
     const computerKeyboardDevice = new ComputerKeyboardDevice(this.context);
-    this.devices.set(computerKeyboardDevice.id, computerKeyboardDevice);
+    this.inputDevices.set(computerKeyboardDevice.id, computerKeyboardDevice);
   }
 
   private listenChanges() {
@@ -101,26 +166,55 @@ export default class MidiDeviceManager {
     this.midiAccess.addEventListener("statechange", (port) => {
       if (port.state === "connected") {
         // Device connected
-        if (this.devices.has(port.id)) return;
-
-        const device = new MidiDevice(port, this.context);
-        this.devices.set(device.id, device);
-
-        this.listeners.forEach((listener) => {
-          listener(device);
-        });
+        if (port.type === "input") {
+          if (this.inputDevices.has(port.id)) return;
+
+          // Find the actual input port from midiAccess
+          for (const input of this.midiAccess!.inputs()) {
+            if (input.id === port.id) {
+              const device = new MidiInputDevice(input, this.context);
+              this.inputDevices.set(device.id, device);
+
+              this.listeners.forEach((listener) => {
+                listener(device);
+              });
+              break;
+            }
+          }
+        } else {
+          // Output device connected
+          if (this.outputDevices.has(port.id)) return;
+
+          // Find the actual output port from midiAccess
+          for (const output of this.midiAccess!.outputs()) {
+            if (output.id === port.id) {
+              const device = new MidiOutputDevice(output);
+              this.outputDevices.set(device.id, device);
+              break;
+            }
+          }
+        }
       } else {
         // Device disconnected
-        const device = this.devices.get(port.id);
-        if (!device) return;
-        if (device instanceof ComputerKeyboardDevice) return;
-
-        device.disconnect();
-        this.devices.delete(device.id);
-
-        this.listeners.forEach((listener) => {
-          listener(device);
-        });
+        if (port.type === "input") {
+          const device = this.inputDevices.get(port.id);
+          if (!device) return;
+          if (device instanceof ComputerKeyboardDevice) return;
+
+          device.disconnect();
+          this.inputDevices.delete(device.id);
+
+          this.listeners.forEach((listener) => {
+            listener(device);
+          });
+        } else {
+          // Output device disconnected
+          const device = this.outputDevices.get(port.id);
+          if (!device) return;
+
+          device.disconnect();
+          this.outputDevices.delete(device.id);
+        }
       }
     });
   }

package/src/core/midi/{MidiDevice.ts → MidiInputDevice.ts}

@@ -1,67 +1,43 @@
 import { Context } from "@blibliki/utils";
+import BaseMidiDevice, { MidiPortState } from "./BaseMidiDevice";
 import Message from "./Message";
 import MidiEvent, { MidiEventType } from "./MidiEvent";
 import type { IMidiInputPort, IMidiMessageEvent } from "./adapters";
 
-export enum MidiPortState {
-  connected = "connected",
-  disconnected = "disconnected",
-}
-
-export type IMidiDevice = {
+export type IMidiInput = {
   id: string;
   name: string;
   state: MidiPortState;
-};
-
-export type IMidiInput = IMidiDevice & {
   eventListerCallbacks: EventListerCallback[];
 };
 
 export type EventListerCallback = (event: MidiEvent) => void;
 
-export default class MidiDevice implements IMidiDevice {
-  id: string;
-  name: string;
+export default class MidiInputDevice extends BaseMidiDevice<IMidiInputPort> {
   eventListerCallbacks: EventListerCallback[] = [];
 
   private context: Readonly<Context>;
-  private input: IMidiInputPort;
   private messageHandler: ((event: IMidiMessageEvent) => void) | null = null;
 
   constructor(input: IMidiInputPort, context: Context) {
-    this.id = input.id;
-    this.name = input.name;
-    this.input = input;
+    super(input);
     this.context = context;
-
-    this.connect();
-  }
-
-  get state() {
-    return this.input.state as MidiPortState;
   }
 
   connect() {
     this.messageHandler = (e: IMidiMessageEvent) => {
       this.processEvent(e);
     };
-    this.input.addEventListener(this.messageHandler);
+    this.midiPort.addEventListener(this.messageHandler);
   }
 
   disconnect() {
     if (this.messageHandler) {
-      this.input.removeEventListener(this.messageHandler);
+      this.midiPort.removeEventListener(this.messageHandler);
       this.messageHandler = null;
     }
   }
 
-  serialize() {
-    const { id, name, state } = this;
-
-    return { id, name, state };
-  }
-
   addEventListener(callback: EventListerCallback) {
     this.eventListerCallbacks.push(callback);
   }

package/src/core/midi/MidiOutputDevice.ts

@@ -0,0 +1,23 @@
+import BaseMidiDevice from "./BaseMidiDevice";
+import type { IMidiOutputPort } from "./adapters";
+
+export default class MidiOutputDevice extends BaseMidiDevice<IMidiOutputPort> {
+  constructor(output: IMidiOutputPort) {
+    super(output);
+    this.connect();
+  }
+
+  connect() {
+    // Output ports don't require connection setup like inputs
+    // This method exists to satisfy the BaseMidiDevice interface
+  }
+
+  disconnect() {
+    // Output ports don't require disconnection cleanup like inputs
+    // This method exists to satisfy the BaseMidiDevice interface
+  }
+
+  send(data: number[] | Uint8Array, timestamp?: number) {
+    this.midiPort.send(data, timestamp);
+  }
+}