@opendaw/studio-core 0.0.23 → 0.0.24

package/dist/capture/Capture.d.ts

@@ -1,17 +1,16 @@
 import { MutableObservableValue, Option, Terminable, UUID } from "@opendaw/lib-std";
 import { AudioUnitBox } from "@opendaw/studio-boxes";
 import { CaptureBox } from "@opendaw/studio-adapters";
-import { RecordingContext } from "./RecordingContext";
-import { CaptureManager } from "./CaptureManager";
+import { CaptureDevices } from "./CaptureDevices";
 export declare abstract class Capture<BOX extends CaptureBox = CaptureBox> implements Terminable {
     #private;
-    protected constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureBox: BOX);
+    protected constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureBox: BOX);
     abstract get label(): string;
     abstract get deviceLabel(): Option<string>;
-    abstract prepareRecording(context: RecordingContext): Promise<void>;
-    abstract startRecording(context: RecordingContext): Terminable;
+    abstract prepareRecording(): Promise<void>;
+    abstract startRecording(): Terminable;
     get uuid(): UUID.Format;
-    get manager(): CaptureManager;
+    get manager(): CaptureDevices;
     get audioUnitBox(): AudioUnitBox;
     get captureBox(): BOX;
     get armed(): MutableObservableValue<boolean>;

package/dist/capture/Capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Capture.d.ts","sourceRoot":"","sources":["../../src/capture/Capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,sBAAsB,EACtB,MAAM,EACN,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AAEnD,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,8BAAsB,OAAO,CAAC,GAAG,SAAS,UAAU,GAAG,UAAU,CAAE,YAAW,UAAU;;IAUpF,SAAS,aAAa,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG;IAmB1F,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAA;IAC5B,QAAQ,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IACnE,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,UAAU;IAE9D,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAyC;IAChE,IAAI,OAAO,IAAI,cAAc,CAAuB;IACpD,IAAI,YAAY,IAAI,YAAY,CAA4B;IAC5D,IAAI,UAAU,IAAI,GAAG,CAA0B;IAC/C,IAAI,KAAK,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAqB;IACjE,IAAI,QAAQ,IAAI,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAwB;IAE9E,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IACpE,SAAS,IAAI,IAAI;CACpB"}
+{"version":3,"file":"Capture.d.ts","sourceRoot":"","sources":["../../src/capture/Capture.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,sBAAsB,EACtB,MAAM,EACN,UAAU,EAEV,IAAI,EACP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAClD,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,8BAAsB,OAAO,CAAC,GAAG,SAAS,UAAU,GAAG,UAAU,CAAE,YAAW,UAAU;;IAUpF,SAAS,aAAa,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG;IAmB1F,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAA;IAC5B,QAAQ,KAAK,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,QAAQ,CAAC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAC1C,QAAQ,CAAC,cAAc,IAAI,UAAU;IAErC,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAyC;IAChE,IAAI,OAAO,IAAI,cAAc,CAAuB;IACpD,IAAI,YAAY,IAAI,YAAY,CAA4B;IAC5D,IAAI,UAAU,IAAI,GAAG,CAA0B;IAC/C,IAAI,KAAK,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAqB;IACjE,IAAI,QAAQ,IAAI,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAwB;IAE9E,GAAG,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAC3C,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,GAAG,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IACpE,SAAS,IAAI,IAAI;CACpB"}

package/dist/capture/CaptureAudio.d.ts

@@ -1,18 +1,17 @@
 import { MutableObservableOption, Option, Terminable } from "@opendaw/lib-std";
 import { AudioUnitBox, CaptureAudioBox } from "@opendaw/studio-boxes";
 import { Capture } from "./Capture";
-import { CaptureManager } from "./CaptureManager";
-import { RecordingContext } from "./RecordingContext";
+import { CaptureDevices } from "./CaptureDevices";
 export declare class CaptureAudio extends Capture<CaptureAudioBox> {
     #private;
-    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureAudioBox: CaptureAudioBox);
+    constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureAudioBox: CaptureAudioBox);
     get gainDb(): number;
     get stream(): MutableObservableOption<MediaStream>;
     get streamDeviceId(): Option<string>;
     get label(): string;
     get deviceLabel(): Option<string>;
     get streamMediaTrack(): Option<MediaStreamTrack>;
-    prepareRecording({}: RecordingContext): Promise<void>;
-    startRecording({ audioContext, worklets, project, sampleManager }: RecordingContext): Terminable;
+    prepareRecording(): Promise<void>;
+    startRecording(): Terminable;
 }
 //# sourceMappingURL=CaptureAudio.d.ts.map

package/dist/capture/CaptureAudio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,uBAAuB,EAAE,MAAM,EAAE,UAAU,EAAO,MAAM,kBAAkB,CAAA;AAExH,OAAO,EAAC,YAAY,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAE/C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AAGnD,qBAAa,YAAa,SAAQ,OAAO,CAAC,eAAe,CAAC;;gBAQ1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IA4BjG,IAAI,MAAM,IAAI,MAAM,CAAsB;IAE1C,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IAExE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IAED,IAAI,KAAK,IAAI,MAAM,CAAsE;IAEzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAEhG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAE3D,cAAc,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA6DjG"}
+{"version":3,"file":"CaptureAudio.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,uBAAuB,EACvB,MAAM,EAEN,UAAU,EAEb,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAC,YAAY,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAI/C,qBAAa,YAAa,SAAQ,OAAO,CAAC,eAAe,CAAC;;gBAQ1C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,eAAe;IA4BjG,IAAI,MAAM,IAAI,MAAM,CAAsB;IAE1C,IAAI,MAAM,IAAI,uBAAuB,CAAC,WAAW,CAAC,CAAsB;IAExE,IAAI,cAAc,IAAI,MAAM,CAAC,MAAM,CAAC,CAEnC;IAED,IAAI,KAAK,IAAI,MAAM,CAAsE;IAEzF,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA+D;IAEhG,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAcvC,cAAc,IAAI,UAAU;CA+D/B"}

package/dist/capture/CaptureAudio.js

@@ -1,4 +1,4 @@
-import { assert, isDefined, isUndefined, MutableObservableOption, Option, warn } from "@opendaw/lib-std";
+import { abort, isDefined, isUndefined, MutableObservableOption, Option, safeExecute, Terminable, warn } from "@opendaw/lib-std";
 import { Promises } from "@opendaw/lib-runtime";
 import { Capture } from "./Capture";
 import { RecordAudio } from "./RecordAudio";
@@ -39,14 +39,29 @@ export class CaptureAudio extends Capture {
     get streamMediaTrack() {
         return this.#stream.flatMap(stream => Option.wrap(stream.getAudioTracks().at(0)));
     }
-    async prepareRecording({}) { return this.#streamGenerator(); }
-    startRecording({ audioContext, worklets, project, sampleManager }) {
+    async prepareRecording() {
+        const { project } = this.manager;
+        const { env: { audioContext } } = project;
+        if (isUndefined(audioContext.outputLatency)) {
+            const approved = await safeExecute(project.env.dialogs?.approve, "Warning", "Your browser does not support 'output latency'. This will cause timing issue while recording.", "Ignore", "Cancel");
+            if (!approved) {
+                return abort("Recording cancelled");
+            }
+        }
+        return this.#streamGenerator();
+    }
+    startRecording() {
+        const { project } = this.manager;
+        const { env: { audioContext, audioWorklets, sampleManager } } = project;
         const streamOption = this.#stream;
-        assert(streamOption.nonEmpty(), "Stream not prepared.");
+        if (streamOption.isEmpty()) {
+            console.warn("No audio stream available for recording.");
+            return Terminable.Empty;
+        }
         const mediaStream = streamOption.unwrap();
         const channelCount = mediaStream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
         const numChunks = 128;
-        const recordingWorklet = worklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
+        const recordingWorklet = audioWorklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
         return RecordAudio.start({
             recordingWorklet,
             mediaStream,
@@ -61,20 +76,16 @@ export class CaptureAudio extends Capture {
         if (this.#stream.nonEmpty()) {
             const stream = this.#stream.unwrap();
             const settings = stream.getAudioTracks().at(0)?.getSettings();
-            console.debug(stream.getAudioTracks());
             if (isDefined(settings)) {
                 const deviceId = this.deviceId.getValue().unwrapOrUndefined();
-                const channelCount = this.#requestChannels.unwrapOrElse(1);
-                const satisfyChannelCount = settings.channelCount === channelCount;
-                const satisfiedDeviceId = isUndefined(deviceId) || deviceId === settings.deviceId;
-                if (satisfiedDeviceId && satisfyChannelCount) {
+                if (isUndefined(deviceId) || deviceId === settings.deviceId) {
                     return Promise.resolve();
                 }
             }
         }
         this.#stopStream();
         const deviceId = this.deviceId.getValue().unwrapOrUndefined();
-        const channelCount = this.#requestChannels.unwrapOrElse(1); // as of today, browsers cap MediaStream audio to stereo.
+        const channelCount = this.#requestChannels.unwrapOrElse(1);
         return AudioDevices.requestStream({
             deviceId: { exact: deviceId },
             sampleRate: this.manager.project.engine.sampleRate(),
@@ -82,12 +93,13 @@ export class CaptureAudio extends Capture {
             echoCancellation: false,
             noiseSuppression: false,
             autoGainControl: false,
-            channelCount
+            channelCount: { ideal: channelCount }
         }).then(stream => {
             const tracks = stream.getAudioTracks();
-            const settings = tracks.at(0)?.getSettings();
+            const track = tracks.at(0);
+            const settings = track?.getSettings();
             const gotDeviceId = settings?.deviceId;
-            console.debug(`new stream id: ${stream.id}, device: ${gotDeviceId ?? "Default"}`);
+            console.debug(`new stream. device requested: ${stream.id}, got: ${gotDeviceId ?? "Default"}. channelCount requested: ${channelCount}, got: ${settings?.channelCount}`);
             if (isUndefined(deviceId) || deviceId === gotDeviceId) {
                 this.#stream.wrap(stream);
             }

package/dist/capture/{CaptureManager.d.ts → CaptureDevices.d.ts}

@@ -1,12 +1,13 @@
 import { Option, Terminable, UUID } from "@opendaw/lib-std";
-import { Project } from "../Project";
+import { Project } from "../project/Project";
 import { Capture } from "./Capture";
-export declare class CaptureManager implements Terminable {
+export declare class CaptureDevices implements Terminable {
     #private;
     constructor(project: Project);
     get project(): Project;
     get(uuid: UUID.Format): Option<Capture>;
+    setArm(subject: Capture, exclusive: boolean): void;
     filterArmed(): ReadonlyArray<Capture>;
     terminate(): void;
 }
-//# sourceMappingURL=CaptureManager.d.ts.map
+//# sourceMappingURL=CaptureDevices.d.ts.map

package/dist/capture/CaptureDevices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CaptureDevices.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureDevices.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,MAAM,EAA2B,UAAU,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAEpH,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,qBAAa,cAAe,YAAW,UAAU;;gBAKjC,OAAO,EAAE,OAAO;IAiB5B,IAAI,OAAO,IAAI,OAAO,CAAuB;IAE7C,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC;IAEvC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAUlD,WAAW,IAAI,aAAa,CAAC,OAAO,CAAC;IAKrC,SAAS,IAAI,IAAI;CAKpB"}

package/dist/capture/{CaptureManager.js → CaptureDevices.js}

@@ -2,7 +2,7 @@ import { asInstanceOf, isDefined, UUID } from "@opendaw/lib-std";
 import { AudioUnitBox } from "@opendaw/studio-boxes";
 import { CaptureMidi } from "./CaptureMidi";
 import { CaptureAudio } from "./CaptureAudio";
-export class CaptureManager {
+export class CaptureDevices {
     #project;
     #subscription;
     #captures;
@@ -26,6 +26,15 @@ export class CaptureManager {
     }
     get project() { return this.#project; }
     get(uuid) { return this.#captures.opt(uuid); }
+    setArm(subject, exclusive) {
+        const arming = !subject.armed.getValue();
+        subject.armed.setValue(arming);
+        if (arming && exclusive) {
+            this.#captures.values()
+                .filter(capture => subject !== capture)
+                .forEach(capture => capture.armed.setValue(false));
+        }
+    }
     filterArmed() {
         return this.#captures.values()
             .filter(capture => capture.armed.getValue() && capture.audioUnitBox.input.pointerHub.nonEmpty());

package/dist/capture/CaptureMidi.d.ts

@@ -1,14 +1,16 @@
-import { Option, Terminable } from "@opendaw/lib-std";
+import { Observer, Option, Subscription, Terminable } from "@opendaw/lib-std";
 import { AudioUnitBox, CaptureMidiBox } from "@opendaw/studio-boxes";
+import { NoteSignal } from "@opendaw/studio-adapters";
 import { Capture } from "./Capture";
-import { RecordingContext } from "./RecordingContext";
-import { CaptureManager } from "./CaptureManager";
+import { CaptureDevices } from "./CaptureDevices";
 export declare class CaptureMidi extends Capture<CaptureMidiBox> {
     #private;
-    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureMidiBox: CaptureMidiBox);
+    constructor(manager: CaptureDevices, audioUnitBox: AudioUnitBox, captureMidiBox: CaptureMidiBox);
+    notify(signal: NoteSignal): void;
+    subscribeNotes(observer: Observer<NoteSignal>): Subscription;
     get label(): string;
     get deviceLabel(): Option<string>;
-    prepareRecording({}: RecordingContext): Promise<void>;
-    startRecording({ project }: RecordingContext): Terminable;
+    prepareRecording(): Promise<void>;
+    startRecording(): Terminable;
 }
 //# sourceMappingURL=CaptureMidi.d.ts.map

package/dist/capture/CaptureMidi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CaptureMidi.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAQH,MAAM,EAEN,UAAU,EAEb,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAC,YAAY,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAI/C,qBAAa,WAAY,SAAQ,OAAO,CAAC,cAAc,CAAC;;gBAQxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IAqC/F,IAAI,KAAK,IAAI,MAAM,CAKlB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAIhC;IAEK,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D,cAAc,CAAC,EAAC,OAAO,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA8C1D"}
+{"version":3,"file":"CaptureMidi.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,UAAU,EAEb,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAC,YAAY,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAA;AAEnD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAA;AAG/C,qBAAa,WAAY,SAAQ,OAAO,CAAC,cAAc,CAAC;;gBAOxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IA8B/F,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAEhC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,YAAY;IAE5D,IAAI,KAAK,IAAI,MAAM,CAgBlB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAIhC;IAEK,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBvC,cAAc,IAAI,UAAU;CAgD/B"}

package/dist/capture/CaptureMidi.js

@@ -1,23 +1,26 @@
-import { asDefined, assert, isDefined, isUndefined, Notifier, Option, Terminable, warn } from "@opendaw/lib-std";
+import { assert, isDefined, isUndefined, Notifier, Option, Terminable, warn } from "@opendaw/lib-std";
 import { Events } from "@opendaw/lib-dom";
 import { MidiData } from "@opendaw/lib-midi";
+import { Promises } from "@opendaw/lib-runtime";
+import { NoteSignal } from "@opendaw/studio-adapters";
+import { MidiDevices } from "../MidiDevices";
 import { Capture } from "./Capture";
 import { RecordMidi } from "./RecordMidi";
-import { MidiDevices } from "../MidiDevices";
-import { Promises } from "@opendaw/lib-runtime";
 export class CaptureMidi extends Capture {
     #streamGenerator;
     #notifier = new Notifier();
     #filterChannel = Option.None;
-    #streaming = Option.None;
+    #stream = Option.None;
     constructor(manager, audioUnitBox, captureMidiBox) {
         super(manager, audioUnitBox, captureMidiBox);
         this.#streamGenerator = Promises.sequential(() => this.#updateStream());
-        this.ownAll(captureMidiBox.channel.subscribe(async (owner) => {
+        this.ownAll(captureMidiBox.channel.catchupAndSubscribe(async (owner) => {
             const channel = owner.getValue();
             this.#filterChannel = channel >= 0 ? Option.wrap(channel) : Option.None;
-            await this.#streamGenerator();
-        }), captureMidiBox.deviceId.catchupAndSubscribe(async () => {
+            if (this.armed.getValue()) {
+                await this.#streamGenerator();
+            }
+        }), captureMidiBox.deviceId.subscribe(async () => {
             if (this.armed.getValue()) {
                 await this.#streamGenerator();
             }
@@ -29,22 +32,27 @@ export class CaptureMidi extends Capture {
             else {
                 this.#stopStream();
             }
-        }), this.#notifier.subscribe(event => {
-            console.debug(MidiData.debug(event.data));
-            const data = asDefined(event.data);
-            const engine = manager.project.engine;
-            if (MidiData.isNoteOn(data)) {
-                engine.noteOn(this.uuid, MidiData.readPitch(data), MidiData.readVelocity(data));
-            }
-            else if (MidiData.isNoteOff(data)) {
-                engine.noteOff(this.uuid, MidiData.readPitch(data));
-            }
-        }));
+        }), this.#notifier.subscribe((signal) => manager.project.engine.noteSignal(signal)));
     }
+    notify(signal) { this.#notifier.notify(signal); }
+    subscribeNotes(observer) { return this.#notifier.subscribe(observer); }
     get label() {
         return MidiDevices.get().mapOr(midiAccess => this.deviceId.getValue().match({
-            none: () => this.armed.getValue() ? "Listening to all MIDI devices" : "Arm to listen to MIDI device...",
-            some: value => `Listening to ${midiAccess.inputs.get(value)?.name}`
+            none: () => this.armed.getValue() ? this.#filterChannel.match({
+                none: () => `Listening to all devices`,
+                some: channel => `Listening to all devices on channel '${channel}'`
+            }) : "Arm to listen to MIDI device...",
+            some: id => {
+                const device = midiAccess.inputs.get(id);
+                if (isUndefined(device)) {
+                    return `⚠️ Could not find device with id '${id}'`;
+                }
+                const deviceName = device.name ?? "Unknown device";
+                return this.#filterChannel.match({
+                    none: () => `Listening to ${deviceName}`,
+                    some: channel => `Listening to ${deviceName} on channel '${channel}'`
+                });
+            }
         }), "MIDI not available");
     }
     get deviceLabel() {
@@ -52,64 +60,76 @@ export class CaptureMidi extends Capture {
             .flatMap(deviceId => MidiDevices.inputs()
             .map(inputs => inputs.find(input => input.id === deviceId)?.name));
     }
-    async prepareRecording({}) {
-        const availableMidiDevices = MidiDevices.get();
-        if (availableMidiDevices.isEmpty()) {
-            return Promise.reject("MIDI is not available");
+    async prepareRecording() {
+        if (MidiDevices.get().isEmpty()) {
+            if (MidiDevices.canRequestMidiAccess()) {
+                await MidiDevices.requestPermission();
+            }
+            else {
+                return warn("MIDI not available");
+            }
+        }
+        const optInputs = MidiDevices.inputs();
+        if (optInputs.isEmpty()) {
+            return warn("MIDI not available");
+        }
+        const inputs = optInputs.unwrap();
+        if (inputs.length === 0) {
+            return;
         }
         const option = this.deviceId.getValue();
         if (option.nonEmpty()) {
-            const { inputs } = availableMidiDevices.unwrap();
-            const captureDevices = Array.from(inputs.values());
             const deviceId = option.unwrap();
-            if (isUndefined(captureDevices.find(device => deviceId === device.id))) {
+            if (isUndefined(inputs.find(device => deviceId === device.id))) {
                 return warn(`Could not find MIDI device with id: '${deviceId}'`);
             }
         }
     }
-    startRecording({ project }) {
+    startRecording() {
         const availableMidiDevices = MidiDevices.inputs();
         assert(availableMidiDevices.nonEmpty(), "No MIDI input devices found");
-        return RecordMidi.start({ notifier: this.#notifier, project, capture: this });
+        return RecordMidi.start({ notifier: this.#notifier, project: this.manager.project, capture: this });
     }
     async #updateStream() {
-        // TODO Check if the requirements have been changed (are different than the current stream setup)
         if (MidiDevices.get().isEmpty()) {
             await MidiDevices.requestPermission();
         }
         const availableMidiDevices = MidiDevices.inputs();
-        const inputs = availableMidiDevices.unwrap();
-        const captureDevices = this.deviceId.getValue().match({
-            none: () => inputs,
-            some: id => inputs.filter(device => id === device.id)
+        const available = availableMidiDevices.unwrap();
+        const capturing = this.deviceId.getValue().match({
+            none: () => available,
+            some: id => available.filter(device => id === device.id)
         });
         const activeNotes = new Int8Array(128);
-        this.#streaming.ifSome(terminable => terminable.terminate());
-        this.#streaming = Option.wrap(Terminable.many(...captureDevices.map(input => Events.subscribe(input, "midimessage", (event) => {
+        this.#stream.ifSome(terminable => terminable.terminate());
+        this.#stream = Option.wrap(Terminable.many(...capturing.map(input => Events.subscribe(input, "midimessage", (event) => {
             const data = event.data;
             if (isDefined(data) &&
                 this.#filterChannel.mapOr(channel => MidiData.readChannel(data) === channel, true)) {
+                const pitch = MidiData.readPitch(data);
                 if (MidiData.isNoteOn(data)) {
-                    activeNotes[MidiData.readPitch(data)]++;
-                    this.#notifier.notify(event);
+                    activeNotes[pitch]++;
+                    this.#notifier.notify(NoteSignal.fromEvent(event, this.uuid));
                 }
-                else if (MidiData.isNoteOff(data)) {
-                    activeNotes[MidiData.readPitch(data)]--;
-                    this.#notifier.notify(event);
+                else if (MidiData.isNoteOff(data) && activeNotes[pitch] > 0) {
+                    activeNotes[pitch]--;
+                    this.#notifier.notify(NoteSignal.fromEvent(event, this.uuid));
                 }
             }
         })), Terminable.create(() => activeNotes.forEach((count, index) => {
             if (count > 0) {
-                // TODO respect channel!
-                const event = new MessageEvent("midimessage", { data: MidiData.noteOff(index, count) });
-                for (let i = 0; i < count; i++) {
-                    this.#notifier.notify(event);
+                for (let channel = 0; channel < 16; channel++) {
+                    const event = new MessageEvent("midimessage", { data: MidiData.noteOff(channel, index) });
+                    const signal = NoteSignal.fromEvent(event, this.uuid);
+                    for (let i = 0; i < count; i++) {
+                        this.#notifier.notify(signal);
+                    }
                 }
             }
         }))));
     }
     #stopStream() {
-        this.#streaming.ifSome(terminable => terminable.terminate());
-        this.#streaming = Option.None;
+        this.#stream.ifSome(terminable => terminable.terminate());
+        this.#stream = Option.None;
     }
 }

package/dist/capture/RecordAudio.d.ts

@@ -1,8 +1,8 @@
 import { Terminable } from "@opendaw/lib-std";
 import { SampleManager } from "@opendaw/studio-adapters";
-import { Project } from "../Project";
-import { Capture } from "./Capture";
+import { Project } from "../project/Project";
 import { RecordingWorklet } from "../RecordingWorklet";
+import { Capture } from "./Capture";
 export declare namespace RecordAudio {
     type RecordAudioContext = {
         recordingWorklet: RecordingWorklet;

package/dist/capture/RecordAudio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGpF,OAAO,EAAC,aAAa,EAAY,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAEjC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AAGpD,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,aAAa,CAAA;QAC5B,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,0FAEG,kBAAkB,KAAG,UA2D3B,CAAA;;CACJ"}
+{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGvG,OAAO,EAAC,aAAa,EAAY,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,aAAa,CAAA;QAC5B,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,0FAAwF,kBAAkB,KACxG,UAqEL,CAAA;;CACJ"}

package/dist/capture/RecordAudio.js

@@ -1,4 +1,4 @@
-import { Option, quantizeFloor, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { Option, quantizeCeil, quantizeFloor, Terminable, Terminator, UUID } from "@opendaw/lib-std";
 import { dbToGain, PPQN } from "@opendaw/lib-dsp";
 import { AudioFileBox, AudioRegionBox } from "@opendaw/studio-boxes";
 import { TrackType } from "@opendaw/studio-adapters";
@@ -17,50 +17,64 @@ export var RecordAudio;
         const streamGain = audioContext.createGain();
         streamGain.gain.value = dbToGain(gainDb);
         streamSource.connect(streamGain);
-        let writing = Option.None;
-        const resizeRegion = () => {
-            if (writing.isEmpty()) {
+        recordingWorklet.own(Terminable.create(() => {
+            streamGain.disconnect();
+            streamSource.disconnect();
+        }));
+        let recordingData = Option.None;
+        const createRecordingData = (position) => editing.modify(() => {
+            const fileDateString = new Date()
+                .toISOString()
+                .replaceAll("T", "-")
+                .replaceAll(".", "-")
+                .replaceAll(":", "-")
+                .replaceAll("Z", "");
+            const fileName = `Recording-${fileDateString}`;
+            const fileBox = AudioFileBox.create(boxGraph, uuid, box => box.fileName.setValue(fileName));
+            const regionBox = AudioRegionBox.create(boxGraph, UUID.generate(), box => {
+                box.file.refer(fileBox);
+                box.regions.refer(trackBox.regions);
+                box.position.setValue(position);
+                box.hue.setValue(ColorCodes.forTrackType(TrackType.Audio));
+                box.label.setValue("Recording");
+            });
+            return { fileBox, regionBox };
+        });
+        const { bpm, env: { audioContext: { sampleRate } } } = project;
+        terminator.ownAll(Terminable.create(() => {
+            if (recordingWorklet.numberOfFrames === 0 || recordingData.isEmpty()) {
+                console.debug("Abort recording audio.");
+                sampleManager.remove(uuid);
+                recordingWorklet.terminate();
+            }
+            else {
+                const { regionBox: { duration } } = recordingData.unwrap("No recording data available");
+                recordingWorklet.limit(PPQN.pulsesToSamples(duration.getValue(), bpm, sampleRate) | 0);
+            }
+        }), engine.position.catchupAndSubscribe(owner => {
+            if (!engine.isRecording.getValue()) {
                 return;
             }
-            const { regionBox } = writing.unwrap();
+            if (recordingData.isEmpty()) {
+                streamGain.connect(recordingWorklet);
+                recordingData = createRecordingData(quantizeFloor(owner.getValue(), beats));
+            }
+            const { regionBox } = recordingData.unwrap();
             editing.modify(() => {
                 if (regionBox.isAttached()) {
                     const { duration, loopDuration } = regionBox;
-                    const newDuration = Math.floor(PPQN.samplesToPulses(recordingWorklet.numberOfFrames, project.timelineBox.bpm.getValue(), audioContext.sampleRate));
+                    const newDuration = quantizeCeil(engine.position.getValue(), beats) - regionBox.position.getValue();
                     duration.setValue(newDuration);
                     loopDuration.setValue(newDuration);
+                    const totalSamples = PPQN.pulsesToSamples(newDuration, project.bpm, sampleRate) | 0;
+                    recordingWorklet.setFillLength(totalSamples);
+                }
+                else {
+                    terminator.terminate();
+                    recordingData = Option.None;
                 }
             }, false);
-        };
-        terminator.ownAll(Terminable.create(() => {
-            recordingWorklet.finalize().then();
-            streamGain.disconnect();
-            streamSource.disconnect();
-        }), engine.position.catchupAndSubscribe(owner => {
-            if (writing.isEmpty() && engine.isRecording.getValue()) {
-                streamGain.connect(recordingWorklet);
-                writing = editing.modify(() => {
-                    const position = quantizeFloor(owner.getValue(), beats);
-                    const fileDateString = new Date()
-                        .toISOString()
-                        .replaceAll("T", "-")
-                        .replaceAll(".", "-")
-                        .replaceAll(":", "-")
-                        .replaceAll("Z", "");
-                    const fileName = `Recording-${fileDateString}`;
-                    const fileBox = AudioFileBox.create(boxGraph, uuid, box => box.fileName.setValue(fileName));
-                    const regionBox = AudioRegionBox.create(boxGraph, UUID.generate(), box => {
-                        box.file.refer(fileBox);
-                        box.regions.refer(trackBox.regions);
-                        box.position.setValue(position);
-                        box.hue.setValue(ColorCodes.forTrackType(TrackType.Audio));
-                        box.label.setValue("Recording");
-                    });
-                    return { fileBox, regionBox };
-                });
-            }
-            resizeRegion();
-        }), Terminable.create(() => resizeRegion()));
+        }));
         return terminator;
     };
 })(RecordAudio || (RecordAudio = {}));

package/dist/capture/RecordMidi.d.ts

@@ -1,9 +1,10 @@
 import { Notifier, Terminable } from "@opendaw/lib-std";
-import { Project } from "../Project";
+import { NoteSignal } from "@opendaw/studio-adapters";
+import { Project } from "../project/Project";
 import { Capture } from "./Capture";
 export declare namespace RecordMidi {
     type RecordMidiContext = {
-        notifier: Notifier<MIDIMessageEvent>;
+        notifier: Notifier<NoteSignal>;
         project: Project;
         capture: Capture;
     };

package/dist/capture/RecordMidi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RecordMidi.d.ts","sourceRoot":"","sources":["../../src/capture/RecordMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,QAAQ,EAIR,UAAU,EAGb,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,yBAAiB,UAAU,CAAC;IACxB,KAAK,iBAAiB,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;QACrC,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAiEvE,CAAA;;CACJ"}
+{"version":3,"file":"RecordMidi.d.ts","sourceRoot":"","sources":["../../src/capture/RecordMidi.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,QAAQ,EAAuC,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGlH,OAAO,EAAC,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAIjC,yBAAiB,UAAU,CAAC;IACxB,KAAK,iBAAiB,GAAG;QACrB,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC/B,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAiEvE,CAAA;;CACJ"}