@blibliki/engine 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blibliki/engine",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "source": "src/index.ts",
   "main": "dist/index.cjs",
@@ -20,7 +20,8 @@
     "@ircam/sc-scheduling": "^1.0.0",
     "node-web-audio-api": "^1.0.3",
     "webmidi": "^3.1.14",
-    "@blibliki/utils": "^0.3.3"
+    "@blibliki/transport": "^0.3.4",
+    "@blibliki/utils": "^0.3.4"
   },
   "scripts": {
     "build": "tsup",

package/src/Engine.ts

@@ -1,14 +1,18 @@
-import { assertDefined, Optional, pick, uuidv4 } from "@blibliki/utils";
 import {
-  IAnyAudioContext,
-  IRoute,
-  Routes,
-  MidiDeviceManager,
-  IModule,
-  TTime,
+  ContextTime,
+  Ticks,
+  TimeSignature,
   Transport,
-  MidiEvent,
-} from "@/core";
+  TransportEvent,
+} from "@blibliki/transport";
+import {
+  assertDefined,
+  Context,
+  Optional,
+  pick,
+  uuidv4,
+} from "@blibliki/utils";
+import { IRoute, Routes, MidiDeviceManager, IModule, MidiEvent } from "@/core";
 import {
   ICreateModule,
   ModuleParams,
@@ -37,10 +41,10 @@ export class Engine {
   ) => void)[] = [];
 
   readonly id: string;
-  context: IAnyAudioContext;
+  context: Context;
   isInitialized = false;
   routes: Routes;
-  transport: Transport;
+  transport: Transport<TransportEvent>;
   modules: Map<
     string,
     ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping]
@@ -61,17 +65,29 @@ export class Engine {
     return this.getById(this._currentId);
   }
 
-  constructor(context: IAnyAudioContext) {
+  constructor(context: Context) {
     this.id = uuidv4();
 
     this.context = context;
-    this.transport = new Transport({
+    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();
-    this.midiDeviceManager = new MidiDeviceManager();
+    this.midiDeviceManager = new MidiDeviceManager(this.context);
 
     Engine._engines.set(this.id, this);
     Engine._currentId = this.id;
@@ -142,17 +158,18 @@ export class Engine {
     );
   }
 
-  async start(props: { offset?: TTime; actionAt?: TTime } = {}) {
+  async start() {
     await this.resume();
-    this.transport.start(props);
+    this.transport.start();
   }
 
-  stop(props: { actionAt?: TTime } = {}) {
-    this.transport.stop(props);
+  stop() {
+    this.transport.stop();
+    this.transport.reset();
   }
 
-  pause(props: { actionAt?: TTime } = {}) {
-    this.transport.pause(props);
+  pause() {
+    this.transport.stop();
   }
 
   get bpm() {
@@ -167,14 +184,10 @@ export class Engine {
     return this.transport.timeSignature;
   }
 
-  set timeSignature(value: [number, number]) {
+  set timeSignature(value: TimeSignature) {
     this.transport.timeSignature = value;
   }
 
-  get playhead() {
-    return this.transport.playhead;
-  }
-
   async resume() {
     await this.context.resume();
   }
@@ -186,8 +199,6 @@ export class Engine {
       module.dispose();
     });
     this.modules.clear();
-    Engine._engines.delete(this.id);
-    Engine._currentId = Engine._engines.keys().next().value;
   }
 
   findModule(
@@ -224,16 +235,20 @@ export class Engine {
     if (virtualMidi.moduleType !== ModuleType.VirtualMidi)
       throw Error("This is not a virtual mid");
 
-    virtualMidi.sendMidi(MidiEvent.fromNote(noteName, type === "noteOn"));
+    virtualMidi.sendMidi(
+      MidiEvent.fromNote(noteName, type === "noteOn", this.context.currentTime),
+    );
   }
 
-  private onStart = (actionAt: TTime) => {
+  // actionAt is context time
+  private onStart = (actionAt: ContextTime) => {
     this.modules.forEach((module) => {
       module.start(actionAt);
     });
   };
 
-  private onStop = (actionAt: TTime) => {
+  // actionAt is context time
+  private onStop = (actionAt: ContextTime) => {
     this.modules.forEach((module) => {
       module.stop(actionAt);
     });

package/src/core/Note/index.ts

@@ -1,5 +1,5 @@
+import { Seconds } from "@blibliki/transport";
 import { Message } from "webmidi";
-import { TTime } from "../Timing/Time";
 import frequencyTable from "./frequencyTable";
 
 const Notes = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
@@ -10,7 +10,7 @@ export type INote = {
   name: string;
   octave: number;
   frequency: number;
-  duration?: TTime;
+  duration?: Seconds;
   velocity?: number;
 };
 
@@ -19,7 +19,7 @@ export default class Note implements INote {
   name!: string;
   octave!: number;
   velocity = 1;
-  duration?: TTime;
+  duration?: Seconds;
 
   static fromFrequency(frequency: number) {
     let noteName: string | undefined;

package/src/core/index.ts

@@ -19,9 +19,6 @@ export type {
   IIOSerialize,
 } from "./IO";
 
-export { Time, TransportState, Transport, t, nt } from "./Timing";
-export type { TTime } from "./Timing";
-
 export type {
   PropDefinition,
   PropSchema,

package/src/core/midi/ComputerKeyboardDevice.ts

@@ -1,3 +1,4 @@
+import { Context } from "@blibliki/utils";
 import Note from "../Note";
 import { EventListerCallback, IMidiInput, MidiPortState } from "./MidiDevice";
 import MidiEvent from "./MidiEvent";
@@ -32,12 +33,14 @@ export default class ComputerKeyboardInput implements IMidiInput {
   name: string;
   state: MidiPortState;
   eventListerCallbacks: EventListerCallback[] = [];
+  private context: Readonly<Context>;
 
-  constructor() {
+  constructor(context: Context) {
     const { id, name, state } = computerKeyboardData();
     this.id = id;
     this.name = name;
     this.state = state;
+    this.context = context;
 
     document.addEventListener("keydown", this.onKeyTrigger(true));
     document.addEventListener("keyup", this.onKeyTrigger(false));
@@ -63,7 +66,11 @@ export default class ComputerKeyboardInput implements IMidiInput {
     const note = this.extractNote(event);
     if (!note) return;
 
-    const midiEvent = MidiEvent.fromNote(note, noteOn);
+    const midiEvent = MidiEvent.fromNote(
+      note,
+      noteOn,
+      this.context.browserToContextTime(event.timeStamp),
+    );
     this.eventListerCallbacks.forEach((callback) => {
       callback(midiEvent);
     });

package/src/core/midi/MidiDevice.ts

@@ -1,5 +1,5 @@
+import { Context } from "@blibliki/utils";
 import { MessageEvent, Input } from "webmidi";
-import { browserToContextTime } from "../Timing";
 import MidiEvent, { MidiEventType } from "./MidiEvent";
 
 export enum MidiPortState {
@@ -24,12 +24,14 @@ export default class MidiDevice implements IMidiDevice {
   name: string;
   eventListerCallbacks: EventListerCallback[] = [];
 
+  private context: Readonly<Context>;
   private input: Input;
 
-  constructor(input: Input) {
+  constructor(input: Input, context: Context) {
     this.id = input.id;
     this.name = input.name || `Device ${input.id}`;
     this.input = input;
+    this.context = context;
 
     this.connect();
   }
@@ -67,7 +69,7 @@ export default class MidiDevice implements IMidiDevice {
   private processEvent(event: MessageEvent) {
     const midiEvent = new MidiEvent(
       event.message,
-      browserToContextTime(event.timestamp),
+      this.context.browserToContextTime(event.timestamp),
     );
 
     switch (midiEvent.type) {

package/src/core/midi/MidiDeviceManager.ts

@@ -1,3 +1,4 @@
+import { Context } from "@blibliki/utils";
 import { Input, Output, WebMidi } from "webmidi";
 import ComputerKeyboardDevice from "./ComputerKeyboardDevice";
 import MidiDevice from "./MidiDevice";
@@ -8,10 +9,11 @@ export default class MidiDeviceManager {
   devices = new Map<string, MidiDevice | ComputerKeyboardDevice>();
   private initialized = false;
   private listeners: ListenerCallback[] = [];
+  private context: Readonly<Context>;
 
-  constructor() {
-    const computerKeyboardDevice = new ComputerKeyboardDevice();
-    this.devices.set(computerKeyboardDevice.id, computerKeyboardDevice);
+  constructor(context: Context) {
+    this.context = context;
+    this.addComputerKeyboard();
   }
 
   async initialize() {
@@ -37,7 +39,7 @@ export default class MidiDeviceManager {
 
       WebMidi.inputs.forEach((input) => {
         if (!this.devices.has(input.id)) {
-          this.devices.set(input.id, new MidiDevice(input));
+          this.devices.set(input.id, new MidiDevice(input, this.context));
         }
       });
     } catch (err) {
@@ -45,6 +47,13 @@ export default class MidiDeviceManager {
     }
   }
 
+  private addComputerKeyboard() {
+    if (typeof document === "undefined") return;
+
+    const computerKeyboardDevice = new ComputerKeyboardDevice(this.context);
+    this.devices.set(computerKeyboardDevice.id, computerKeyboardDevice);
+  }
+
   private listenChanges() {
     WebMidi.addListener("connected", (event) => {
       const port = event.port as Input | Output;
@@ -52,7 +61,7 @@ export default class MidiDeviceManager {
 
       if (this.devices.has(port.id)) return;
 
-      const device = new MidiDevice(port);
+      const device = new MidiDevice(port, this.context);
       this.devices.set(device.id, device);
 
       this.listeners.forEach((listener) => {

package/src/core/midi/MidiEvent.ts

@@ -1,6 +1,6 @@
+import { ContextTime } from "@blibliki/transport";
 import { Message } from "webmidi";
 import Note, { INote } from "../Note";
-import { t, TTime } from "../Timing/Time";
 
 export enum MidiEventType {
   noteOn = "noteon",
@@ -11,29 +11,33 @@ export enum MidiEventType {
 export default class MidiEvent {
   note?: Note;
   voiceNo?: number;
-  readonly triggeredAt: TTime;
+  readonly triggeredAt: ContextTime;
   private message: Message;
 
   static fromNote(
     noteName: string | Note | Omit<INote, "frequency">,
     noteOn = true,
-    triggeredAt?: TTime,
+    triggeredAt: ContextTime,
   ): MidiEvent {
     const note = noteName instanceof Note ? noteName : new Note(noteName);
 
     return new MidiEvent(new Message(note.midiData(noteOn)), triggeredAt);
   }
 
-  static fromCC(cc: number, value: number, triggeredAt?: TTime): MidiEvent {
+  static fromCC(
+    cc: number,
+    value: number,
+    triggeredAt: ContextTime,
+  ): MidiEvent {
     return new MidiEvent(
       new Message(new Uint8Array([0xb0, cc, value])),
       triggeredAt,
     );
   }
 
-  constructor(message: Message, triggeredAt?: TTime) {
+  constructor(message: Message, triggeredAt: ContextTime) {
     this.message = message;
-    this.triggeredAt = triggeredAt ?? t();
+    this.triggeredAt = triggeredAt;
     this.defineNotes();
   }
 

package/src/core/module/Module.ts

@@ -1,7 +1,7 @@
-import { Optional, upperFirst, uuidv4 } from "@blibliki/utils";
+import { ContextTime } from "@blibliki/transport";
+import { Context, Optional, upperFirst, uuidv4 } from "@blibliki/utils";
 import { Engine } from "@/Engine";
 import { AnyModule, ModuleType, ModuleTypeToPropsMapping } from "@/modules";
-import { IAnyAudioContext } from "../";
 import {
   AudioInputProps,
   AudioOutputProps,
@@ -13,7 +13,6 @@ import {
   MidiOutputProps,
 } from "../IO";
 import Note from "../Note";
-import { TTime } from "../Timing/Time";
 import MidiEvent, { MidiEventType } from "../midi/MidiEvent";
 
 export type IModule<T extends ModuleType> = {
@@ -33,7 +32,7 @@ export type IModuleConstructor<T extends ModuleType> = Optional<
   IModule<T>,
   "id" | "voiceNo"
 > & {
-  audioNodeConstructor?: (context: IAnyAudioContext) => AudioNode;
+  audioNodeConstructor?: (context: Context) => AudioNode;
 };
 
 export abstract class Module<T extends ModuleType> implements IModule<T> {
@@ -130,21 +129,21 @@ export abstract class Module<T extends ModuleType> implements IModule<T> {
     this.outputs.unPlugAll();
   }
 
-  start(_time: TTime): void {
+  start(_time: ContextTime): void {
     // Optional implementation in modules
   }
 
-  stop(_time: TTime): void {
+  stop(_time: ContextTime): void {
     // Optional implementation in modules
   }
 
-  triggerAttack(note: Note, _triggeredAt: TTime): void {
+  triggerAttack(note: Note, _triggeredAt: ContextTime): void {
     if (this.activeNotes.some((n) => n.fullName === note.fullName)) return;
 
     this.activeNotes.push(note);
   }
 
-  triggerRelease(note: Note, _triggeredAt: TTime): void {
+  triggerRelease(note: Note, _triggeredAt: ContextTime): void {
     this.activeNotes = this.activeNotes.filter(
       (n) => n.fullName !== note.fullName,
     );

package/src/core/module/PolyModule.ts

@@ -1,3 +1,4 @@
+import { ContextTime } from "@blibliki/transport";
 import { deterministicId, Optional, uuidv4 } from "@blibliki/utils";
 import { Engine } from "@/Engine";
 import { ModuleType, ModuleTypeToPropsMapping } from "@/modules";
@@ -10,7 +11,6 @@ import {
   OutputCollection,
 } from "../IO";
 import { PolyAudioInputProps, PolyAudioOutputProps } from "../IO/PolyAudioIO";
-import { TTime } from "../Timing";
 import MidiEvent from "../midi/MidiEvent";
 import { IModule, IModuleConstructor, Module } from "./Module";
 
@@ -101,13 +101,13 @@ export abstract class PolyModule<T extends ModuleType>
     this.rePlugAll();
   }
 
-  start(time: TTime): void {
+  start(time: ContextTime): void {
     this.audioModules.forEach((m) => {
       m.start(time);
     });
   }
 
-  stop(time: TTime): void {
+  stop(time: ContextTime): void {
     this.audioModules.forEach((m) => {
       m.stop(time);
     });

package/src/core/module/VoiceScheduler.ts

@@ -1,7 +1,7 @@
+import { ContextTime } from "@blibliki/transport";
 import { EmptyObject } from "@blibliki/utils";
 import { ICreateModule, ModuleType } from "@/modules";
 import { MidiOutput } from "../IO";
-import { nt, t, TTime } from "../Timing/Time";
 import MidiEvent, { MidiEventType } from "../midi/MidiEvent";
 import { PropSchema } from "../schema";
 import { IModuleConstructor, Module } from "./Module";
@@ -14,7 +14,7 @@ const DEFAULT_PROPS = {};
 class Voice extends Module<ModuleType.VoiceScheduler> {
   declare audioNode: undefined;
   activeNote: string | null = null;
-  triggeredAt: TTime = t(0);
+  triggeredAt: ContextTime = 0;
 
   constructor(
     engineId: string,
@@ -102,7 +102,7 @@ export default class VoiceScheduler extends PolyModule<ModuleType.VoiceScheduler
 
     // If no available voice, get the one with the lowest triggeredAt
     voice ??= this.audioModules.sort((a, b) => {
-      return nt(a.triggeredAt) - nt(b.triggeredAt);
+      return a.triggeredAt - b.triggeredAt;
     })[0];
 
     return voice;

package/src/index.ts

@@ -16,10 +16,13 @@ export type {
   BooleanProp,
   ArrayProp,
   INote,
-  t,
-  nt,
 } from "./core";
-export { TransportState, MidiDevice, MidiPortState, Note } from "./core";
+export { MidiDevice, MidiPortState, Note } from "./core";
+
+export { TransportState } from "@blibliki/transport";
+export type { TimeSignature, Position } from "@blibliki/transport";
+
+export { Context } from "@blibliki/utils";
 
 export { ModuleType, moduleSchemas, OscillatorWave } from "./modules";
 export type {

package/src/modules/BiquadFilter.ts

@@ -1,5 +1,5 @@
-import { IAnyAudioContext, Module } from "@/core";
-import { IModuleConstructor } from "@/core/module/Module";
+import { Context } from "@blibliki/utils";
+import { IModuleConstructor, Module } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { PropSchema } from "@/core/schema";
 import { createModule, ICreateModule, ModuleType } from ".";
@@ -63,8 +63,8 @@ class MonoBiquadFilter extends Module<ModuleType.BiquadFilter> {
   ) {
     const props = { ...DEFAULT_PROPS, ...params.props };
 
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      new BiquadFilterNode(context, {
+    const audioNodeConstructor = (context: Context) =>
+      new BiquadFilterNode(context.audioContext, {
         type: props.type,
         frequency: props.cutoff,
         Q: props.Q,

package/src/modules/Constant.ts

@@ -1,6 +1,7 @@
-import { IAnyAudioContext, IModule, Module } from "@/core";
+import { ContextTime } from "@blibliki/transport";
+import { Context } from "@blibliki/utils";
+import { IModule, Module } from "@/core";
 import Note from "@/core/Note";
-import { nt, TTime } from "@/core/Timing/Time";
 import { PropSchema } from "@/core/schema";
 import { ICreateModule, ModuleType } from ".";
 
@@ -27,8 +28,8 @@ export default class Constant extends Module<ModuleType.Constant> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Constant>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) =>
-      new ConstantSourceNode(context);
+    const audioNodeConstructor = (context: Context) =>
+      new ConstantSourceNode(context.audioContext);
 
     super(engineId, {
       ...params,
@@ -43,17 +44,17 @@ export default class Constant extends Module<ModuleType.Constant> {
     this.audioNode.offset.value = value;
   }
 
-  start(time: TTime) {
+  start(time: ContextTime) {
     if (this.isStated) return;
 
     this.isStated = true;
-    this.audioNode.start(nt(time));
+    this.audioNode.start(time);
   }
 
-  stop(time: TTime) {
-    this.audioNode.stop(nt(time));
+  stop(time: ContextTime) {
+    this.audioNode.stop(time);
     this.rePlugAll(() => {
-      this.audioNode = new ConstantSourceNode(this.context, {
+      this.audioNode = new ConstantSourceNode(this.context.audioContext, {
         offset: this.props.value,
       });
     });
@@ -61,8 +62,8 @@ export default class Constant extends Module<ModuleType.Constant> {
     this.isStated = false;
   }
 
-  triggerAttack = (note: Note, triggeredAt: TTime) => {
-    this.audioNode.offset.setValueAtTime(note.frequency, nt(triggeredAt));
+  triggerAttack = (note: Note, triggeredAt: ContextTime) => {
+    this.audioNode.offset.setValueAtTime(note.frequency, triggeredAt);
     this.start(triggeredAt);
   };
 

package/src/modules/Envelope.ts

@@ -1,7 +1,7 @@
-import { createScaleNormalized } from "@blibliki/utils";
-import { IAnyAudioContext, Module } from "@/core";
+import { ContextTime } from "@blibliki/transport";
+import { Context, createScaleNormalized } from "@blibliki/utils";
+import { Module } from "@/core";
 import Note from "@/core/Note";
-import { nt, TTime } from "@/core/Timing/Time";
 import { IModuleConstructor } from "@/core/module/Module";
 import { IPolyModuleConstructor, PolyModule } from "@/core/module/PolyModule";
 import { PropSchema } from "@/core/schema";
@@ -67,8 +67,8 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
 
   constructor(engineId: string, params: ICreateModule<ModuleType.Envelope>) {
     const props = { ...DEFAULT_PROPS, ...params.props };
-    const audioNodeConstructor = (context: IAnyAudioContext) => {
-      const audioNode = new GainNode(context);
+    const audioNodeConstructor = (context: Context) => {
+      const audioNode = new GainNode(context.audioContext);
       audioNode.gain.value = 0;
       return audioNode;
     };
@@ -82,65 +82,60 @@ class MonoEnvelope extends Module<ModuleType.Envelope> {
     this.registerDefaultIOs();
   }
 
-  triggerAttack(note: Note, triggeredAt: TTime) {
+  triggerAttack(note: Note, triggeredAt: ContextTime) {
     super.triggerAttack(note, triggeredAt);
 
     const attack = this.scaledAttack();
     const decay = this.scaledDecay();
     const sustain = this.props.sustain;
-    const triggeredAtNum = nt(triggeredAt);
 
-    this.audioNode.gain.cancelAndHoldAtTime(triggeredAtNum);
+    this.audioNode.gain.cancelAndHoldAtTime(triggeredAt);
 
     // Always start from a tiny value, can't ramp from 0
     if (this.audioNode.gain.value === 0) {
-      this.audioNode.gain.setValueAtTime(0.001, triggeredAtNum);
+      this.audioNode.gain.setValueAtTime(0.001, triggeredAt);
     }
 
     // Attack
-    this.audioNode.gain.exponentialRampToValueAtTime(
-      1.0,
-      triggeredAtNum + attack,
-    );
+    this.audioNode.gain.exponentialRampToValueAtTime(1.0, triggeredAt + attack);
 
     // Decay
     if (sustain > 0) {
       this.audioNode.gain.exponentialRampToValueAtTime(
         sustain,
-        triggeredAtNum + attack + decay,
+        triggeredAt + attack + decay,
       );
       // Do not set to zero or anything else!
     } else {
       this.audioNode.gain.exponentialRampToValueAtTime(
         0.001,
-        triggeredAtNum + attack + decay,
+        triggeredAt + attack + decay,
       );
     }
   }
 
-  triggerRelease(note: Note, triggeredAt: TTime) {
+  triggerRelease(note: Note, triggeredAt: ContextTime) {
     super.triggerRelease(note, triggeredAt);
     if (this.activeNotes.length > 0) return;
 
     const release = this.scaledRelease();
-    const triggeredAtNum = nt(triggeredAt);
 
     // Cancel scheduled automations and set gain to the ACTUAL value at this moment
-    this.audioNode.gain.cancelAndHoldAtTime(triggeredAtNum);
+    this.audioNode.gain.cancelAndHoldAtTime(triggeredAt);
     const currentGainValue = this.audioNode.gain.value;
 
     if (currentGainValue >= 0.0001) {
       // Always set the value at the release time to ensure a smooth ramp from here
-      this.audioNode.gain.setValueAtTime(currentGainValue, triggeredAtNum);
+      this.audioNode.gain.setValueAtTime(currentGainValue, triggeredAt);
       // Exponential ramp to a tiny value
       this.audioNode.gain.exponentialRampToValueAtTime(
         0.0001,
-        triggeredAtNum + release - 0.0001,
+        triggeredAt + release - 0.0001,
       );
     }
 
     // Set to zero at the very end
-    this.audioNode.gain.setValueAtTime(0, triggeredAtNum + release);
+    this.audioNode.gain.setValueAtTime(0, triggeredAt + release);
   }
 
   private scaledAttack() {