@opendaw/studio-core 0.0.6

package/README.md

@@ -0,0 +1 @@
+This package is part of the openDAW SDK

package/dist/Engine.d.ts

@@ -0,0 +1,21 @@
+import { ppqn } from "@opendaw/lib-dsp";
+import { byte, DefaultObservableValue, int, MutableObservableValue, Nullable, ObservableValue, Observer, Subscription, unitValue, UUID } from "@opendaw/lib-std";
+import { ClipNotification } from "@opendaw/studio-adapters";
+export interface Engine {
+    position(): ObservableValue<ppqn>;
+    isPlaying(): MutableObservableValue<boolean>;
+    isRecording(): MutableObservableValue<boolean>;
+    metronomeEnabled(): MutableObservableValue<boolean>;
+    isReady(): Promise<void>;
+    queryLoadingComplete(): Promise<boolean>;
+    stop(): void;
+    panic(): void;
+    noteOn(uuid: UUID.Format, pitch: byte, velocity: unitValue): void;
+    noteOff(uuid: UUID.Format, pitch: byte): void;
+    scheduleClipPlay(...clipIds: ReadonlyArray<UUID.Format>): void;
+    scheduleClipStop(...trackIds: ReadonlyArray<UUID.Format>): void;
+    requestPosition(position: ppqn): void;
+    subscribeClipNotification(observer: Observer<ClipNotification>): Subscription;
+    markerState(): DefaultObservableValue<Nullable<[UUID.Format, int]>>;
+}
+//# sourceMappingURL=Engine.d.ts.map

package/dist/Engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../src/Engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EACH,IAAI,EACJ,sBAAsB,EACtB,GAAG,EACH,sBAAsB,EACtB,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAA;AAEzD,MAAM,WAAW,MAAM;IACnB,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,CAAA;IACjC,SAAS,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAA;IAC5C,WAAW,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAA;IAC9C,gBAAgB,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAA;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;IACxC,IAAI,IAAI,IAAI,CAAA;IACZ,KAAK,IAAI,IAAI,CAAA;IACb,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAA;IACjE,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CAAA;IAC7C,gBAAgB,CAAC,GAAG,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IAC9D,gBAAgB,CAAC,GAAG,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAA;IAC/D,eAAe,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAA;IACrC,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,YAAY,CAAA;IAC7E,WAAW,IAAI,sBAAsB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;CACtE"}

package/dist/Engine.js

@@ -0,0 +1 @@
+export {};

package/dist/EngineFacade.d.ts

@@ -0,0 +1,28 @@
+import { byte, DefaultObservableValue, int, MutableObservableValue, Nullable, ObservableValue, Observer, Subscription, unitValue, UUID } from "@opendaw/lib-std";
+import { ppqn } from "@opendaw/lib-dsp";
+import { ClipNotification } from "@opendaw/studio-adapters";
+import { Engine } from "./Engine";
+import { EngineWorklet } from "./EngineWorklet";
+export declare class EngineFacade implements Engine {
+    #private;
+    setClient(client: EngineWorklet): void;
+    playbackTimestamp(): MutableObservableValue<ppqn>;
+    position(): ObservableValue<ppqn>;
+    isPlaying(): MutableObservableValue<boolean>;
+    isRecording(): MutableObservableValue<boolean>;
+    metronomeEnabled(): MutableObservableValue<boolean>;
+    markerState(): DefaultObservableValue<Nullable<[UUID.Format, int]>>;
+    isReady(): Promise<void>;
+    queryLoadingComplete(): Promise<boolean>;
+    stop(): void;
+    panic(): void;
+    sampleRate(): number;
+    subscribeClipNotification(observer: Observer<ClipNotification>): Subscription;
+    noteOn(uuid: UUID.Format, pitch: byte, velocity: unitValue): void;
+    noteOff(uuid: UUID.Format, pitch: byte): void;
+    scheduleClipPlay(...clipIds: ReadonlyArray<UUID.Format>): void;
+    scheduleClipStop(...trackIds: ReadonlyArray<UUID.Format>): void;
+    requestPosition(position: ppqn): void;
+    terminate(): void;
+}
+//# sourceMappingURL=EngineFacade.d.ts.map

package/dist/EngineFacade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineFacade.d.ts","sourceRoot":"","sources":["../src/EngineFacade.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,IAAI,EACJ,sBAAsB,EACtB,GAAG,EACH,sBAAsB,EACtB,QAAQ,EACR,eAAe,EACf,QAAQ,EAER,YAAY,EAEZ,SAAS,EACT,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAC/B,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAA;AAE7C,qBAAa,YAAa,YAAW,MAAM;;IAWvC,SAAS,CAAC,MAAM,EAAE,aAAa;IAuB/B,iBAAiB,IAAI,sBAAsB,CAAC,IAAI,CAAC;IACjD,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC;IACjC,SAAS,IAAI,sBAAsB,CAAC,OAAO,CAAC;IAC5C,WAAW,IAAI,sBAAsB,CAAC,OAAO,CAAC;IAC9C,gBAAgB,IAAI,sBAAsB,CAAC,OAAO,CAAC;IACnD,WAAW,IAAI,sBAAsB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACnE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IACxB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;IAGxC,IAAI,IAAI,IAAI;IACZ,KAAK,IAAI,IAAI;IACb,UAAU,IAAI,MAAM;IACpB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,YAAY;IAG7E,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,GAAG,IAAI;IAGjE,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI;IAC7C,gBAAgB,CAAC,GAAG,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI;IAC9D,gBAAgB,CAAC,GAAG,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI;IAC/D,eAAe,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI;IAErC,SAAS,IAAI,IAAI;CAKpB"}

package/dist/EngineFacade.js

@@ -0,0 +1,50 @@
+import { DefaultObservableValue, Option, Terminator } from "@opendaw/lib-std";
+export class EngineFacade {
+    #terminator = new Terminator();
+    #playbackTimestamp = new DefaultObservableValue(0.0);
+    #position = new DefaultObservableValue(0.0);
+    #isPlaying = new DefaultObservableValue(false);
+    #isRecording = new DefaultObservableValue(false);
+    #metronomeEnabled = new DefaultObservableValue(false);
+    #markerState = new DefaultObservableValue(null);
+    #client = Option.None;
+    setClient(client) {
+        this.#client = Option.wrap(client);
+        this.#terminator.terminate();
+        this.#terminator.ownAll(client.playbackTimestamp().subscribe(owner => this.#playbackTimestamp.setValue(owner.getValue())), client.position().subscribe(owner => this.#position.setValue(owner.getValue())), client.isPlaying().subscribe(owner => this.#isPlaying.setValue(owner.getValue())), client.isRecording().subscribe(owner => this.#isRecording.setValue(owner.getValue())), client.metronomeEnabled().subscribe(owner => this.#metronomeEnabled.setValue(owner.getValue())), client.markerState().subscribe(owner => this.#markerState.setValue(owner.getValue())), this.position().subscribe(owner => client.position().setValue(owner.getValue())), this.isPlaying().subscribe(owner => client.isPlaying().setValue(owner.getValue())), this.isRecording().subscribe(owner => client.isRecording().setValue(owner.getValue())), this.metronomeEnabled().subscribe(owner => client.metronomeEnabled().setValue(owner.getValue())));
+        this.#playbackTimestamp.setValue(client.playbackTimestamp().getValue());
+        this.#position.setValue(client.position().getValue());
+        this.#isPlaying.setValue(client.isPlaying().getValue());
+        this.#isRecording.setValue(client.isRecording().getValue());
+        this.#metronomeEnabled.setValue(client.metronomeEnabled().getValue());
+        this.#markerState.setValue(client.markerState().getValue());
+    }
+    playbackTimestamp() { return this.#playbackTimestamp; }
+    position() { return this.#position; }
+    isPlaying() { return this.#isPlaying; }
+    isRecording() { return this.#isRecording; }
+    metronomeEnabled() { return this.#metronomeEnabled; }
+    markerState() { return this.#markerState; }
+    isReady() { return this.#client.mapOr(client => client.isReady(), Promise.resolve()); }
+    queryLoadingComplete() {
+        return this.#client.mapOr(client => client.queryLoadingComplete(), Promise.resolve(false));
+    }
+    stop() { this.#client.ifSome(client => client.stop()); }
+    panic() { this.#client.ifSome(client => client.panic()); }
+    sampleRate() { return this.#client.isEmpty() ? 44_100 : this.#client.unwrap().context.sampleRate; }
+    subscribeClipNotification(observer) {
+        return this.#client.unwrap().subscribeClipNotification(observer);
+    }
+    noteOn(uuid, pitch, velocity) {
+        this.#client.unwrap("No engine").noteOn(uuid, pitch, velocity);
+    }
+    noteOff(uuid, pitch) { this.#client.unwrap("No engine").noteOff(uuid, pitch); }
+    scheduleClipPlay(...clipIds) { this.#client.unwrap("No engine").scheduleClipPlay(...clipIds); }
+    scheduleClipStop(...trackIds) { this.#client.unwrap("No engine").scheduleClipStop(...trackIds); }
+    requestPosition(position) { this.#client.unwrap("No engine").requestPosition(position); }
+    terminate() {
+        this.#terminator.terminate();
+        this.#client.ifSome(client => client.terminate());
+        this.#client = Option.None;
+    }
+}

package/dist/EngineWorklet.d.ts

@@ -0,0 +1,30 @@
+import { byte, DefaultObservableValue, int, MutableObservableValue, Nullable, Observer, Subscription, unitValue, UUID } from "@opendaw/lib-std";
+import { ppqn } from "@opendaw/lib-dsp";
+import { ClipNotification, ExportStemsConfiguration } from "@opendaw/studio-adapters";
+import { Project } from "./Project";
+import { WorkletFactory } from "./WorkletFactory";
+export declare class EngineWorklet extends AudioWorkletNode {
+    #private;
+    static bootFactory(context: BaseAudioContext, url: string): Promise<WorkletFactory<EngineWorklet>>;
+    static ID: int;
+    readonly id: number;
+    constructor(context: BaseAudioContext, project: Readonly<Project>, exportConfiguration?: ExportStemsConfiguration);
+    stop(): void;
+    panic(): void;
+    isPlaying(): MutableObservableValue<boolean>;
+    isRecording(): MutableObservableValue<boolean>;
+    playbackTimestamp(): DefaultObservableValue<number>;
+    position(): MutableObservableValue<ppqn>;
+    metronomeEnabled(): DefaultObservableValue<boolean>;
+    isReady(): Promise<void>;
+    queryLoadingComplete(): Promise<boolean>;
+    noteOn(uuid: UUID.Format, pitch: byte, velocity: unitValue): void;
+    noteOff(uuid: UUID.Format, pitch: byte): void;
+    scheduleClipPlay(...clipIds: ReadonlyArray<UUID.Format>): void;
+    scheduleClipStop(...trackIds: ReadonlyArray<UUID.Format>): void;
+    requestPosition(position: ppqn): void;
+    subscribeClipNotification(observer: Observer<ClipNotification>): Subscription;
+    markerState(): DefaultObservableValue<Nullable<[UUID.Format, int]>>;
+    terminate(): void;
+}
+//# sourceMappingURL=EngineWorklet.d.ts.map

package/dist/EngineWorklet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineWorklet.d.ts","sourceRoot":"","sources":["../src/EngineWorklet.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,IAAI,EACJ,sBAAsB,EACtB,GAAG,EACH,sBAAsB,EAEtB,QAAQ,EACR,QAAQ,EAER,YAAY,EAGZ,SAAS,EACT,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACrC,OAAO,EAEH,gBAAgB,EAOhB,wBAAwB,EAC3B,MAAM,0BAA0B,CAAA;AAKjC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;;IAC/C,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;IAIlG,MAAM,CAAC,EAAE,EAAE,GAAG,CAAQ;IAEtB,QAAQ,CAAC,EAAE,SAAqB;gBAgBpB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,EAC1B,mBAAmB,CAAC,EAAE,wBAAwB;IA2G1D,IAAI,IAAI,IAAI;IASZ,KAAK,IAAI,IAAI;IACb,SAAS,IAAI,sBAAsB,CAAC,OAAO,CAAC;IAC5C,WAAW,IAAI,sBAAsB,CAAC,OAAO,CAAC;IAC9C,iBAAiB,IAAI,sBAAsB,CAAC,MAAM,CAAC;IACnD,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC;IACxC,gBAAgB,IAAI,sBAAsB,CAAC,OAAO,CAAC;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IACxB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC;IACxC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,GAAG,IAAI;IACjE,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI;IAC7C,gBAAgB,CAAC,GAAG,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI;IAK9D,gBAAgB,CAAC,GAAG,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI;IAG/D,eAAe,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI;IAIrC,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,GAAG,YAAY;IAQ7E,WAAW,IAAI,sBAAsB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAInE,SAAS,IAAI,IAAI;CAKpB"}

package/dist/EngineWorklet.js

@@ -0,0 +1,168 @@
+import { Arrays, DefaultObservableValue, Notifier, Option, SyncStream, Terminator, UUID } from "@opendaw/lib-std";
+import { EngineStateSchema, ExportStemsConfiguration } from "@opendaw/studio-adapters";
+import { SyncSource } from "@opendaw/lib-box";
+import { AnimationFrame } from "@opendaw/lib-dom";
+import { Communicator, Messenger } from "@opendaw/lib-runtime";
+import { WorkletFactory } from "./WorkletFactory";
+export class EngineWorklet extends AudioWorkletNode {
+    static bootFactory(context, url) {
+        return WorkletFactory.boot(context, url);
+    }
+    static ID = 0 | 0;
+    id = EngineWorklet.ID++;
+    #terminator = new Terminator();
+    #playbackTimestamp = new DefaultObservableValue(0.0);
+    #position = new DefaultObservableValue(0.0);
+    #isPlaying = new DefaultObservableValue(false);
+    #isRecording = new DefaultObservableValue(false);
+    #metronomeEnabled = new DefaultObservableValue(false);
+    #markerState = new DefaultObservableValue(null);
+    #notifyClipNotification;
+    #playingClips;
+    #commands;
+    #isReady;
+    #ignoreUpdates = false;
+    constructor(context, project, exportConfiguration) {
+        console.debug("constructor");
+        const numberOfChannels = ExportStemsConfiguration.countStems(Option.wrap(exportConfiguration)) * 2;
+        const reader = SyncStream.reader(EngineStateSchema(), state => {
+            this.#ignoreUpdates = true;
+            this.#position.setValue(state.position);
+            this.#ignoreUpdates = false;
+        });
+        super(context, "engine-processor", {
+            numberOfInputs: 0,
+            numberOfOutputs: 1,
+            outputChannelCount: [numberOfChannels],
+            processorOptions: {
+                sab: reader.buffer,
+                project: project.toArrayBuffer(),
+                exportConfiguration
+            }
+        });
+        const { resolve, promise } = Promise.withResolvers();
+        const messenger = Messenger.for(this.port);
+        this.#isReady = promise;
+        this.#notifyClipNotification = this.#terminator.own(new Notifier());
+        this.#playingClips = [];
+        this.#commands = this.#terminator.own(Communicator.sender(messenger.channel("engine-commands"), dispatcher => new class {
+            setPlaying(value) { dispatcher.dispatchAndForget(this.setPlaying, value); }
+            setRecording(value) { dispatcher.dispatchAndForget(this.setRecording, value); }
+            setPosition(position) { dispatcher.dispatchAndForget(this.setPosition, position); }
+            setMetronomeEnabled(enabled) { dispatcher.dispatchAndForget(this.setMetronomeEnabled, enabled); }
+            stopAndReset() { dispatcher.dispatchAndForget(this.stopAndReset); }
+            queryLoadingComplete() {
+                return dispatcher.dispatchAndReturn(this.queryLoadingComplete);
+            }
+            panic() { dispatcher.dispatchAndForget(this.panic); }
+            noteOn(uuid, pitch, velocity) {
+                dispatcher.dispatchAndForget(this.noteOn, uuid, pitch, velocity);
+            }
+            noteOff(uuid, pitch) {
+                dispatcher.dispatchAndForget(this.noteOff, uuid, pitch);
+            }
+            scheduleClipPlay(clipIds) {
+                dispatcher.dispatchAndForget(this.scheduleClipPlay, clipIds);
+            }
+            scheduleClipStop(trackIds) {
+                dispatcher.dispatchAndForget(this.scheduleClipStop, trackIds);
+            }
+            terminate() { dispatcher.dispatchAndForget(this.terminate); }
+        }));
+        Communicator.executor(messenger.channel("engine-to-client"), {
+            log: (message) => console.log("WORKLET", message),
+            ready: () => resolve(),
+            fetchAudio: (uuid) => {
+                return new Promise((resolve, reject) => {
+                    const handler = project.audioManager.getOrCreate(uuid);
+                    handler.subscribe(state => {
+                        if (state.type === "error") {
+                            reject(state.reason);
+                        }
+                        else if (state.type === "loaded") {
+                            resolve(handler.data.unwrap());
+                        }
+                    });
+                });
+            },
+            notifyClipSequenceChanges: (changes) => {
+                changes.stopped.forEach(uuid => {
+                    for (let i = 0; i < this.#playingClips.length; i++) {
+                        if (UUID.equals(this.#playingClips[i], uuid)) {
+                            this.#playingClips.splice(i, 1);
+                            break;
+                        }
+                    }
+                });
+                changes.started.forEach(uuid => this.#playingClips.push(uuid));
+                this.#notifyClipNotification.notify({ type: "sequencing", changes });
+            },
+            switchMarkerState: (state) => this.#markerState.setValue(state)
+        });
+        this.#terminator.ownAll(AnimationFrame.add(() => reader.tryRead()), project.liveStreamReceiver.connect(messenger.channel("engine-live-data")), new SyncSource(project.boxGraph, messenger.channel("engine-sync"), false), this.#isPlaying.catchupAndSubscribe(owner => {
+            const isPlaying = owner.getValue();
+            if (isPlaying) {
+                this.#commands.setPosition(this.#playbackTimestamp.getValue());
+            }
+            else if (this.#isRecording.getValue()) {
+                this.#isRecording.setValue(false);
+            }
+            this.#commands.setPlaying(isPlaying);
+        }), this.#isRecording.subscribe(owner => {
+            const willRecord = owner.getValue();
+            this.#commands.setPlaying(willRecord);
+            this.#commands.setRecording(willRecord);
+        }), this.#metronomeEnabled.catchupAndSubscribe(owner => this.#commands.setMetronomeEnabled(owner.getValue())), this.#position.catchupAndSubscribe(owner => {
+            if (!this.#ignoreUpdates) {
+                this.#commands.setPosition(owner.getValue());
+            }
+        }));
+    }
+    stop() {
+        if (!this.#isPlaying.getValue() && this.#position.getValue() === 0.0) {
+            this.#commands.stopAndReset();
+        }
+        else {
+            this.#isRecording.setValue(false);
+            this.#isPlaying.setValue(false);
+            this.requestPosition(0.0);
+        }
+    }
+    panic() { this.#commands.panic(); }
+    isPlaying() { return this.#isPlaying; }
+    isRecording() { return this.#isRecording; }
+    playbackTimestamp() { return this.#playbackTimestamp; }
+    position() { return this.#position; }
+    metronomeEnabled() { return this.#metronomeEnabled; }
+    isReady() { return this.#isReady; }
+    queryLoadingComplete() { return this.#commands.queryLoadingComplete(); }
+    noteOn(uuid, pitch, velocity) { this.#commands.noteOn(uuid, pitch, velocity); }
+    noteOff(uuid, pitch) { this.#commands.noteOff(uuid, pitch); }
+    scheduleClipPlay(...clipIds) {
+        this.#notifyClipNotification.notify({ type: "waiting", clips: clipIds });
+        this.#commands.scheduleClipPlay(clipIds);
+        this.#isPlaying.setValue(true); // must be second, since they might be executed in different blocks
+    }
+    scheduleClipStop(...trackIds) {
+        this.#commands.scheduleClipStop(trackIds);
+    }
+    requestPosition(position) {
+        this.#playbackTimestamp.setValue(position);
+        this.#commands.setPosition(position);
+    }
+    subscribeClipNotification(observer) {
+        observer({
+            type: "sequencing",
+            changes: { started: this.#playingClips, stopped: Arrays.empty(), obsolete: Arrays.empty() }
+        });
+        return this.#notifyClipNotification.subscribe(observer);
+    }
+    markerState() {
+        return this.#markerState;
+    }
+    terminate() {
+        console.debug(`terminate EngineClient id: ${this.id}`);
+        this.#terminator.terminate();
+        this.disconnect();
+    }
+}

package/dist/MeterWorklet.d.ts

@@ -0,0 +1,15 @@
+import { int, Observer, Subscription, Terminable } from "@opendaw/lib-std";
+import { WorkletFactory } from "./WorkletFactory";
+export type PeakSchema = {
+    peak: Float32Array;
+    rms: Float32Array;
+};
+export declare class MeterWorklet extends AudioWorkletNode implements Terminable {
+    #private;
+    static bootFactory(context: BaseAudioContext, url: string): Promise<WorkletFactory<MeterWorklet>>;
+    static create(factory: WorkletFactory<MeterWorklet>, numChannels: int): MeterWorklet;
+    private constructor();
+    subscribe(observer: Observer<PeakSchema>): Subscription;
+    terminate(): void;
+}
+//# sourceMappingURL=MeterWorklet.d.ts.map

package/dist/MeterWorklet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeterWorklet.d.ts","sourceRoot":"","sources":["../src/MeterWorklet.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAY,QAAQ,EAAU,YAAY,EAAc,UAAU,EAAa,MAAM,kBAAkB,CAAA;AAElH,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAE,CAAA;AAElE,qBAAa,YAAa,SAAQ,gBAAiB,YAAW,UAAU;;WACvD,WAAW,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAIvG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,cAAc,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,GAAG,GAAG,YAAY;IAOpF,OAAO;IAmBP,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,YAAY;IAEvD,SAAS,IAAI,IAAI;CACpB"}

package/dist/MeterWorklet.js

@@ -0,0 +1,33 @@
+import { Notifier, Schema, SyncStream, Terminator } from "@opendaw/lib-std";
+import { AnimationFrame } from "@opendaw/lib-dom";
+import { WorkletFactory } from "./WorkletFactory";
+export class MeterWorklet extends AudioWorkletNode {
+    static async bootFactory(context, url) {
+        return WorkletFactory.boot(context, url);
+    }
+    static create(factory, numChannels) {
+        return factory.create(context => new MeterWorklet(context, numChannels));
+    }
+    #terminator = new Terminator();
+    #notifier = new Notifier();
+    constructor(context, numberOfChannels) {
+        const receiver = SyncStream.reader(Schema.createBuilder({
+            peak: Schema.floats(numberOfChannels),
+            rms: Schema.floats(numberOfChannels)
+        })(), (data) => this.#notifier.notify(data));
+        super(context, "peak-meter-processor", {
+            numberOfInputs: 1,
+            channelCount: numberOfChannels,
+            channelCountMode: "explicit",
+            processorOptions: {
+                sab: receiver.buffer,
+                numberOfChannels,
+                rmsWindowInSeconds: 0.100,
+                valueDecay: 0.200
+            }
+        });
+        this.#terminator.own(AnimationFrame.add(() => receiver.tryRead()));
+    }
+    subscribe(observer) { return this.#notifier.subscribe(observer); }
+    terminate() { this.#terminator.terminate(); }
+}

package/dist/Mixer.d.ts

@@ -0,0 +1,13 @@
+import { Terminable } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { AudioUnitBoxAdapter, SortedBoxAdapterCollection } from "@opendaw/studio-adapters";
+export interface ChannelStripView {
+    silent(value: boolean): void;
+}
+export declare class Mixer implements Terminable {
+    #private;
+    constructor(audioUnits: SortedBoxAdapterCollection<AudioUnitBoxAdapter, Pointers.AudioUnits>);
+    registerChannelStrip({ uuid }: AudioUnitBoxAdapter, view: ChannelStripView): Terminable;
+    terminate(): void;
+}
+//# sourceMappingURL=Mixer.d.ts.map

package/dist/Mixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mixer.d.ts","sourceRoot":"","sources":["../src/Mixer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwD,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AACpH,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAC,mBAAmB,EAAE,0BAA0B,EAAC,MAAM,0BAA0B,CAAA;AAIxF,MAAM,WAAW,gBAAgB;IAC7B,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;CAC/B;AAQD,qBAAa,KAAM,YAAW,UAAU;;gBAOxB,UAAU,EAAE,0BAA0B,CAAC,mBAAmB,EAAE,QAAQ,CAAC,UAAU,CAAC;IAuC5F,oBAAoB,CAAC,EAAC,IAAI,EAAC,EAAE,mBAAmB,EAAE,IAAI,EAAE,gBAAgB,GAAG,UAAU;IASrF,SAAS,IAAI,IAAI;CAqDpB"}

package/dist/Mixer.js

@@ -0,0 +1,110 @@
+import { Arrays, asDefined, EmptyExec, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { deferNextFrame } from "@opendaw/lib-dom";
+export class Mixer {
+    #terminator = new Terminator();
+    #states;
+    #solo;
+    #virtualSolo;
+    #deferUpdate;
+    constructor(audioUnits) {
+        this.#states = UUID.newSet(({ adapter: { uuid } }) => uuid);
+        this.#solo = new Set();
+        this.#virtualSolo = new Set();
+        this.#deferUpdate = this.#terminator.own(deferNextFrame(() => this.#updateStates()));
+        this.#terminator.own(audioUnits.catchupAndSubscribe({
+            onAdd: (adapter) => {
+                const { mute, solo } = adapter.namedParameter;
+                const views = [];
+                this.#states.add({
+                    adapter,
+                    views,
+                    subscription: Terminable.many(mute.catchupAndSubscribe(owner => {
+                        if (owner.getControlledValue()) {
+                            views.forEach(view => view.silent(true));
+                        }
+                        else {
+                            this.#deferUpdate.request();
+                        }
+                    }), solo.catchupAndSubscribe(owner => {
+                        if (owner.getControlledValue()) {
+                            this.#solo.add(adapter);
+                        }
+                        else {
+                            this.#solo.delete(adapter);
+                        }
+                        this.#deferUpdate.request();
+                    }))
+                });
+            },
+            onRemove: (adapter) => {
+                this.#solo.delete(adapter);
+                this.#states.removeByKey(adapter.uuid).subscription.terminate();
+                this.#deferUpdate.request();
+            },
+            onReorder: EmptyExec
+        }));
+    }
+    registerChannelStrip({ uuid }, view) {
+        this.#states.get(uuid).views.push(view);
+        this.#deferUpdate.request();
+        return Terminable.create(() => {
+            this.#states.opt(uuid).ifSome(({ views }) => Arrays.remove(views, view));
+            this.#deferUpdate.request();
+        });
+    }
+    terminate() { this.#terminator.terminate(); }
+    #updateStates() {
+        this.#virtualSolo.clear();
+        this.#processChannelStrips();
+        this.#updateChannelStripViews();
+    }
+    #processChannelStrips() {
+        const touched = new Set();
+        const processUpstreamChannels = (adapter) => {
+            if (touched.has(adapter)) {
+                return;
+            }
+            touched.add(adapter);
+            adapter.input.getValue().ifSome(input => {
+                if (input.type === "bus") {
+                    input.box.input.pointerHub
+                        .filter(Pointers.AudioOutput)
+                        .map(pointer => this.#resolveAdapter(pointer.box))
+                        .forEach((adapter) => {
+                        const { namedParameter: { solo } } = adapter;
+                        if (!solo.getControlledValue()) {
+                            this.#virtualSolo.add(adapter);
+                        }
+                        processUpstreamChannels(adapter);
+                    });
+                }
+            });
+        };
+        this.#states.forEach(({ adapter }) => {
+            const { namedParameter: { solo } } = adapter;
+            if (solo.getControlledValue()) {
+                processUpstreamChannels(adapter);
+            }
+        });
+    }
+    #resolveAdapter(box) {
+        return asDefined(box.accept({
+            visitAudioUnitBox: ({ address: { uuid } }) => this.#states.get(uuid).adapter,
+            visitAuxSendBox: ({ audioUnit: { targetVertex } }) => this.#states.get(targetVertex.unwrap().address.uuid).adapter
+        }), "Could not resolve entry");
+    }
+    #updateChannelStripViews() {
+        this.#states.forEach(({ adapter, views }) => {
+            const { mute, solo } = adapter.namedParameter;
+            if (mute.getControlledValue()) {
+                views.forEach(view => view.silent(true));
+            }
+            else {
+                const isSolo = solo.getControlledValue() || this.#virtualSolo.has(adapter);
+                const value = this.#solo.size > 0 && !isSolo && !adapter.isOutput;
+                views.forEach(view => view.silent(value));
+            }
+        });
+    }
+}

package/dist/Project.d.ts

@@ -0,0 +1,41 @@
+import { Terminable, TerminableOwner, Terminator } from "@opendaw/lib-std";
+import { BoxGraph, Editing } from "@opendaw/lib-box";
+import { AudioBusBox, AudioUnitBox, BoxIO, RootBox, TimelineBox, UserInterfaceBox } from "@opendaw/studio-boxes";
+import { AudioLoaderManager, BoxAdapters, BoxAdaptersContext, ClipSequencing, ParameterFieldAdapters, RootBoxAdapter, TimelineBoxAdapter, UserEditingManager, VertexSelection } from "@opendaw/studio-adapters";
+import { LiveStreamBroadcaster, LiveStreamReceiver } from "@opendaw/lib-fusion";
+import { ProjectEnv } from "./ProjectEnv";
+import { Mixer } from "./Mixer";
+export declare class Project implements BoxAdaptersContext, Terminable, TerminableOwner {
+    #private;
+    static new(env: ProjectEnv): Project;
+    static load(env: ProjectEnv, arrayBuffer: ArrayBuffer): Project;
+    readonly boxGraph: BoxGraph<BoxIO.TypeMap>;
+    readonly rootBox: RootBox;
+    readonly userInterfaceBox: UserInterfaceBox;
+    readonly masterBusBox: AudioBusBox;
+    readonly masterAudioUnit: AudioUnitBox;
+    readonly timelineBox: TimelineBox;
+    readonly editing: Editing;
+    readonly selection: VertexSelection;
+    readonly boxAdapters: BoxAdapters;
+    readonly userEditingManager: UserEditingManager;
+    readonly parameterFieldAdapters: ParameterFieldAdapters;
+    readonly liveStreamReceiver: LiveStreamReceiver;
+    readonly mixer: Mixer;
+    private constructor();
+    own<T extends Terminable>(terminable: T): T;
+    ownAll<T extends Terminable>(...terminables: Array<T>): void;
+    spawn(): Terminator;
+    get bpm(): number;
+    get rootBoxAdapter(): RootBoxAdapter;
+    get timelineBoxAdapter(): TimelineBoxAdapter;
+    get audioManager(): AudioLoaderManager;
+    get clipSequencing(): ClipSequencing;
+    get isAudioContext(): boolean;
+    get isMainThread(): boolean;
+    get liveStreamBroadcaster(): LiveStreamBroadcaster;
+    toArrayBuffer(): ArrayBufferLike;
+    copy(): Project;
+    terminate(): void;
+}
+//# sourceMappingURL=Project.d.ts.map

package/dist/Project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Project.d.ts","sourceRoot":"","sources":["../src/Project.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,UAAU,EACV,eAAe,EACf,UAAU,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,QAAQ,EAAE,OAAO,EAAC,MAAM,kBAAkB,CAAA;AAClD,OAAO,EACH,WAAW,EACX,YAAY,EACZ,KAAK,EAGL,OAAO,EACP,WAAW,EACX,gBAAgB,EAInB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACH,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAClB,cAAc,EAGd,sBAAsB,EAEtB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EAClB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,qBAAqB,EAAE,kBAAkB,EAAC,MAAM,qBAAqB,CAAA;AAE7E,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AACvC,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAA;AAI7B,qBAAa,OAAQ,YAAW,kBAAkB,EAAE,UAAU,EAAE,eAAe;;IAC3E,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAuCpC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO;IA8D/D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAE1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAA;IAC3C,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAA;IAClC,QAAQ,CAAC,eAAe,EAAE,YAAY,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IAEjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;IACnC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,sBAAsB,EAAE,sBAAsB,CAAA;IACvD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IAErB,OAAO;IA6BP,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI;IAC5D,KAAK,IAAI,UAAU;IAEnB,IAAI,GAAG,IAAI,MAAM,CAAyC;IAC1D,IAAI,cAAc,IAAI,cAAc,CAAmE;IACvG,IAAI,kBAAkB,IAAI,kBAAkB,CAA2E;IACvH,IAAI,YAAY,IAAI,kBAAkB,CAAgC;IACtE,IAAI,cAAc,IAAI,cAAc,CAAkD;IACtF,IAAI,cAAc,IAAI,OAAO,CAAe;IAC5C,IAAI,YAAY,IAAI,OAAO,CAAc;IACzC,IAAI,qBAAqB,IAAI,qBAAqB,CAAkD;IAEpG,aAAa,IAAI,eAAe;IAiBhC,IAAI,IAAI,OAAO;IAEf,SAAS,IAAI,IAAI;CACpB"}