@opendaw/studio-core 0.0.19 → 0.0.21

package/dist/capture/Capture.js

@@ -0,0 +1,32 @@
+import { DefaultObservableValue, MappedMutableObservableValue, Option, Terminator } from "@opendaw/lib-std";
+export class Capture {
+    #terminator = new Terminator();
+    #manager;
+    #audioUnitBox;
+    #captureBox;
+    #deviceId;
+    #armed;
+    constructor(manager, audioUnitBox, captureBox) {
+        this.#manager = manager;
+        this.#audioUnitBox = audioUnitBox;
+        this.#captureBox = captureBox;
+        this.#deviceId = new MappedMutableObservableValue(captureBox.deviceId, {
+            fx: x => x.length > 0 ? Option.wrap(x) : Option.None,
+            fy: y => y.match({ none: () => "", some: x => x })
+        });
+        this.#armed = this.#terminator.own(new DefaultObservableValue(false));
+        this.#terminator.ownAll(this.#captureBox.deviceId.catchupAndSubscribe(owner => {
+            const id = owner.getValue();
+            this.#deviceId.setValue(id.length > 0 ? Option.wrap(id) : Option.None);
+        }));
+    }
+    get uuid() { return this.#audioUnitBox.address.uuid; }
+    get manager() { return this.#manager; }
+    get audioUnitBox() { return this.#audioUnitBox; }
+    get captureBox() { return this.#captureBox; }
+    get armed() { return this.#armed; }
+    get deviceId() { return this.#deviceId; }
+    own(terminable) { return this.#terminator.own(terminable); }
+    ownAll(...terminables) { this.#terminator.ownAll(...terminables); }
+    terminate() { this.#terminator.terminate(); }
+}

package/dist/capture/CaptureAudio.d.ts

@@ -0,0 +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";
+export declare class CaptureAudio extends Capture<CaptureAudioBox> {
+    #private;
+    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureAudioBox: CaptureAudioBox);
+    get gainDb(): number;
+    get stream(): MutableObservableOption<MediaStream>;
+    get streamDeviceId(): Option<string>;
+    get deviceLabel(): Option<string>;
+    get streamMediaTrack(): Option<MediaStreamTrack>;
+    prepareRecording({}: RecordingContext): Promise<void>;
+    startRecording({ audioContext, worklets, project, sampleManager }: RecordingContext): Terminable;
+}
+//# sourceMappingURL=CaptureAudio.d.ts.map

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

@@ -0,0 +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,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAEhC;IAED,IAAI,gBAAgB,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAE/C;IAEK,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3D,cAAc,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA6DjG"}

package/dist/capture/CaptureAudio.js

@@ -0,0 +1,106 @@
+import { assert, isDefined, isUndefined, MutableObservableOption, Option, warn } from "@opendaw/lib-std";
+import { Promises } from "@opendaw/lib-runtime";
+import { Capture } from "./Capture";
+import { RecordAudio } from "./RecordAudio";
+import { AudioDevices } from "../AudioDevices";
+export class CaptureAudio extends Capture {
+    #stream;
+    #streamGenerator;
+    #requestChannels = Option.None;
+    #gainDb = 0.0;
+    constructor(manager, audioUnitBox, captureAudioBox) {
+        super(manager, audioUnitBox, captureAudioBox);
+        this.#stream = new MutableObservableOption();
+        this.#streamGenerator = Promises.sequential(() => this.#updateStream());
+        this.ownAll(captureAudioBox.requestChannels.catchupAndSubscribe(owner => {
+            const channels = owner.getValue();
+            this.#requestChannels = channels === 1 || channels === 2 ? Option.wrap(channels) : Option.None;
+        }), captureAudioBox.gainDb.catchupAndSubscribe(owner => this.#gainDb = owner.getValue()), captureAudioBox.deviceId.catchupAndSubscribe(async () => {
+            if (this.armed.getValue()) {
+                await this.#streamGenerator();
+            }
+        }), this.armed.catchupAndSubscribe(async (owner) => {
+            const armed = owner.getValue();
+            if (armed) {
+                await this.#streamGenerator();
+            }
+            else {
+                this.#stopStream();
+            }
+        }));
+    }
+    get gainDb() { return this.#gainDb; }
+    get stream() { return this.#stream; }
+    get streamDeviceId() {
+        return this.streamMediaTrack.map(settings => settings.getSettings().deviceId ?? "");
+    }
+    get deviceLabel() {
+        return this.streamMediaTrack.map(track => track.label ?? "");
+    }
+    get streamMediaTrack() {
+        return this.#stream.flatMap(stream => Option.wrap(stream.getAudioTracks().at(0)));
+    }
+    async prepareRecording({}) {
+        return this.#streamGenerator();
+    }
+    startRecording({ audioContext, worklets, project, sampleManager }) {
+        const streamOption = this.#stream;
+        assert(streamOption.nonEmpty(), "Stream not prepared.");
+        const mediaStream = streamOption.unwrap();
+        const channelCount = mediaStream.getAudioTracks().at(0)?.getSettings().channelCount ?? 1;
+        const numChunks = 128;
+        const recordingWorklet = worklets.createRecording(channelCount, numChunks, audioContext.outputLatency);
+        return RecordAudio.start({
+            recordingWorklet,
+            mediaStream,
+            sampleManager,
+            audioContext,
+            project,
+            capture: this,
+            gainDb: this.#gainDb
+        });
+    }
+    async #updateStream() {
+        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) {
+                    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.
+        return AudioDevices.requestStream({
+            deviceId: { exact: deviceId },
+            sampleRate: this.manager.project.engine.sampleRate(),
+            sampleSize: 32,
+            echoCancellation: false,
+            noiseSuppression: false,
+            autoGainControl: false,
+            channelCount
+        }).then(stream => {
+            const tracks = stream.getAudioTracks();
+            const settings = tracks.at(0)?.getSettings();
+            const gotDeviceId = settings?.deviceId;
+            console.debug(`new stream id: ${stream.id}, device: ${gotDeviceId ?? "Default"}`);
+            if (isUndefined(deviceId) || deviceId === gotDeviceId) {
+                this.#stream.wrap(stream);
+            }
+            else {
+                stream.getAudioTracks().forEach(track => track.stop());
+                return warn(`Could not find audio device with id: '${deviceId} in ${gotDeviceId}'`);
+            }
+        });
+    }
+    #stopStream() {
+        this.#stream.clear(stream => stream.getAudioTracks().forEach(track => track.stop()));
+    }
+}

package/dist/capture/CaptureManager.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CaptureManager.d.ts","sourceRoot":"","sources":["../../src/capture/CaptureManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,MAAM,EAA2B,UAAU,EAAE,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAEpH,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,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,WAAW,IAAI,aAAa,CAAC,OAAO,CAAC;IAKrC,SAAS,IAAI,IAAI;CAKpB"}

package/dist/capture/CaptureManager.js

@@ -0,0 +1,38 @@
+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 {
+    #project;
+    #subscription;
+    #captures;
+    constructor(project) {
+        this.#project = project;
+        this.#captures = UUID.newSet(unit => unit.uuid);
+        this.#subscription = this.#project.rootBox.audioUnits.pointerHub.catchupAndSubscribeTransactual({
+            onAdd: ({ box }) => {
+                const audioUnitBox = asInstanceOf(box, AudioUnitBox);
+                const capture = audioUnitBox.capture.targetVertex
+                    .ifSome(({ box }) => box.accept({
+                    visitCaptureMidiBox: (box) => new CaptureMidi(this, audioUnitBox, box),
+                    visitCaptureAudioBox: (box) => new CaptureAudio(this, audioUnitBox, box)
+                }));
+                if (isDefined(capture)) {
+                    this.#captures.add(capture);
+                }
+            },
+            onRemove: ({ box: { address: { uuid } } }) => this.#captures.removeByKeyIfExist(uuid)?.terminate()
+        });
+    }
+    get project() { return this.#project; }
+    get(uuid) { return this.#captures.opt(uuid); }
+    filterArmed() {
+        return this.#captures.values()
+            .filter(capture => capture.armed.getValue() && capture.audioUnitBox.input.pointerHub.nonEmpty());
+    }
+    terminate() {
+        this.#subscription.terminate();
+        this.#captures.forEach(capture => capture.terminate());
+        this.#captures.clear();
+    }
+}

package/dist/capture/CaptureMidi.d.ts

@@ -0,0 +1,13 @@
+import { Option, Terminable } from "@opendaw/lib-std";
+import { AudioUnitBox, CaptureMidiBox } from "@opendaw/studio-boxes";
+import { Capture } from "./Capture";
+import { RecordingContext } from "./RecordingContext";
+import { CaptureManager } from "./CaptureManager";
+export declare class CaptureMidi extends Capture<CaptureMidiBox> {
+    #private;
+    constructor(manager: CaptureManager, audioUnitBox: AudioUnitBox, captureMidiBox: CaptureMidiBox);
+    get deviceLabel(): Option<string>;
+    prepareRecording({}: RecordingContext): Promise<void>;
+    startRecording({ project }: RecordingContext): Terminable;
+}
+//# sourceMappingURL=CaptureMidi.d.ts.map

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

@@ -0,0 +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;IAsC/F,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAA0C;IAErE,gBAAgB,CAAC,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB3D,cAAc,CAAC,EAAC,OAAO,EAAC,EAAE,gBAAgB,GAAG,UAAU;CA8C1D"}

package/dist/capture/CaptureMidi.js

@@ -0,0 +1,106 @@
+import { asDefined, assert, isDefined, isUndefined, Notifier, Option, Terminable, warn } from "@opendaw/lib-std";
+import { Events } from "@opendaw/lib-dom";
+import { MidiData } from "@opendaw/lib-midi";
+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;
+    constructor(manager, audioUnitBox, captureMidiBox) {
+        super(manager, audioUnitBox, captureMidiBox);
+        this.#streamGenerator = Promises.sequential(() => this.#updateStream());
+        this.ownAll(captureMidiBox.channel.subscribe(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();
+            }
+        }), this.armed.catchupAndSubscribe(async (owner) => {
+            const armed = owner.getValue();
+            if (armed) {
+                await this.#streamGenerator();
+            }
+            else {
+                this.#stopStream();
+            }
+        }), this.#notifier.subscribe(event => {
+            console.debug(MidiData.debug(event.data));
+            const data = asDefined(event.data);
+            const engine = manager.project.engine;
+            const isNoteOn = MidiData.isNoteOn(data);
+            if (MidiData.isNoteOff(data) || (isNoteOn && MidiData.readVelocity(data) === 0)) {
+                engine.noteOff(this.uuid, MidiData.readPitch(data));
+            }
+            else if (isNoteOn) {
+                engine.noteOn(this.uuid, MidiData.readPitch(data), MidiData.readVelocity(data));
+            }
+        }));
+    }
+    get deviceLabel() { return Option.wrap("MIDI coming soon."); }
+    async prepareRecording({}) {
+        const availableMidiDevices = MidiDevices.get();
+        if (availableMidiDevices.isEmpty()) {
+            return Promise.reject("MIDI is not available");
+        }
+        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))) {
+                return warn(`Could not find MIDI device with id: '${deviceId}'`);
+            }
+        }
+    }
+    startRecording({ project }) {
+        const availableMidiDevices = MidiDevices.inputs();
+        assert(availableMidiDevices.nonEmpty(), "No MIDI input devices found");
+        return RecordMidi.start({ notifier: this.#notifier, 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 activeNotes = new Int8Array(128);
+        this.#streaming.ifSome(terminable => terminable.terminate());
+        this.#streaming = Option.wrap(Terminable.many(...captureDevices.map(input => Events.subscribe(input, "midimessage", (event) => {
+            const data = event.data;
+            if (isDefined(data) &&
+                this.#filterChannel.mapOr(channel => MidiData.readChannel(data) === channel, true)) {
+                if (MidiData.isNoteOn(data)) {
+                    activeNotes[MidiData.readPitch(data)]++;
+                    this.#notifier.notify(event);
+                }
+                else if (MidiData.isNoteOff(data)) {
+                    activeNotes[MidiData.readPitch(data)]--;
+                    this.#notifier.notify(event);
+                }
+            }
+        })), 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);
+                }
+            }
+        }))));
+    }
+    #stopStream() {
+        this.#streaming.ifSome(terminable => terminable.terminate());
+        this.#streaming = Option.None;
+    }
+}

package/dist/capture/RecordAudio.d.ts

@@ -0,0 +1,19 @@
+import { Terminable } from "@opendaw/lib-std";
+import { SampleManager } from "@opendaw/studio-adapters";
+import { Project } from "../Project";
+import { Capture } from "./Capture";
+import { RecordingWorklet } from "../RecordingWorklet";
+export declare namespace RecordAudio {
+    type RecordAudioContext = {
+        recordingWorklet: RecordingWorklet;
+        mediaStream: MediaStream;
+        sampleManager: SampleManager;
+        audioContext: AudioContext;
+        project: Project;
+        capture: Capture;
+        gainDb: number;
+    };
+    export const start: ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb }: RecordAudioContext) => Terminable;
+    export {};
+}
+//# sourceMappingURL=RecordAudio.d.ts.map

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

@@ -0,0 +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"}

package/dist/capture/RecordAudio.js

@@ -0,0 +1,66 @@
+import { Option, 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";
+import { RecordTrack } from "./RecordTrack";
+import { ColorCodes } from "../ColorCodes";
+export var RecordAudio;
+(function (RecordAudio) {
+    RecordAudio.start = ({ recordingWorklet, mediaStream, sampleManager, audioContext, project, capture, gainDb }) => {
+        const terminator = new Terminator();
+        const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
+        const { editing, engine, boxGraph } = project;
+        const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Audio);
+        const uuid = recordingWorklet.uuid;
+        sampleManager.record(recordingWorklet);
+        const streamSource = audioContext.createMediaStreamSource(mediaStream);
+        const streamGain = audioContext.createGain();
+        streamGain.gain.value = dbToGain(gainDb);
+        streamSource.connect(streamGain);
+        let writing = Option.None;
+        const resizeRegion = () => {
+            if (writing.isEmpty()) {
+                return;
+            }
+            const { regionBox } = writing.unwrap();
+            editing.modify(() => {
+                if (regionBox.isAttached()) {
+                    const { duration, loopDuration } = regionBox;
+                    const newDuration = Math.floor(PPQN.samplesToPulses(recordingWorklet.numberOfFrames, project.timelineBox.bpm.getValue(), audioContext.sampleRate));
+                    duration.setValue(newDuration);
+                    loopDuration.setValue(newDuration);
+                }
+            }, 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

@@ -0,0 +1,13 @@
+import { Notifier, Terminable } from "@opendaw/lib-std";
+import { Project } from "../Project";
+import { Capture } from "./Capture";
+export declare namespace RecordMidi {
+    type RecordMidiContext = {
+        notifier: Notifier<MIDIMessageEvent>;
+        project: Project;
+        capture: Capture;
+    };
+    export const start: ({ notifier, project, capture }: RecordMidiContext) => Terminable;
+    export {};
+}
+//# sourceMappingURL=RecordMidi.d.ts.map

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

@@ -0,0 +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"}

package/dist/capture/RecordMidi.js

@@ -0,0 +1,85 @@
+import { isUndefined, Option, quantizeCeil, quantizeFloor, Terminator, UUID } from "@opendaw/lib-std";
+import { PPQN } from "@opendaw/lib-dsp";
+import { MidiData } from "@opendaw/lib-midi";
+import { NoteEventBox, NoteEventCollectionBox, NoteRegionBox } from "@opendaw/studio-boxes";
+import { TrackType } from "@opendaw/studio-adapters";
+import { RecordTrack } from "./RecordTrack";
+import { ColorCodes } from "../ColorCodes";
+export var RecordMidi;
+(function (RecordMidi) {
+    RecordMidi.start = ({ notifier, project, capture }) => {
+        console.debug("RecordMidi.start");
+        const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
+        const { editing, boxGraph } = project;
+        const trackBox = RecordTrack.findOrCreate(editing, capture.audioUnitBox, TrackType.Notes);
+        const terminator = new Terminator();
+        const activeNotes = new Map();
+        let writing = Option.None;
+        terminator.own(project.engine.position.catchupAndSubscribe(owner => {
+            if (writing.isEmpty()) {
+                return;
+            }
+            const writePosition = owner.getValue();
+            const { region, collection } = writing.unwrap();
+            editing.modify(() => {
+                if (region.isAttached() && collection.isAttached()) {
+                    const { position, duration, loopDuration } = region;
+                    const newDuration = quantizeCeil(writePosition, beats) - position.getValue();
+                    duration.setValue(newDuration);
+                    loopDuration.setValue(newDuration);
+                    for (const event of activeNotes.values()) {
+                        if (event.isAttached()) {
+                            event.duration.setValue(writePosition - event.position.getValue());
+                        }
+                        else {
+                            activeNotes.delete(event.pitch.getValue());
+                        }
+                    }
+                }
+                else {
+                    writing = Option.None;
+                }
+            }, false);
+        }));
+        terminator.ownAll(notifier.subscribe((event) => {
+            if (!project.engine.isRecording.getValue()) {
+                return;
+            }
+            const data = event.data;
+            if (isUndefined(data)) {
+                return;
+            }
+            const position = project.engine.position.getValue();
+            if (MidiData.isNoteOn(data)) {
+                const pitch = MidiData.readParam1(data);
+                if (writing.isEmpty()) {
+                    editing.modify(() => {
+                        const collection = NoteEventCollectionBox.create(boxGraph, UUID.generate());
+                        const region = NoteRegionBox.create(boxGraph, UUID.generate(), box => {
+                            box.regions.refer(trackBox.regions);
+                            box.events.refer(collection.owners);
+                            box.position.setValue(quantizeFloor(position, beats));
+                            box.hue.setValue(ColorCodes.forTrackType(TrackType.Notes));
+                        });
+                        writing = Option.wrap({ region, collection });
+                    }, false);
+                }
+                const { collection } = writing.unwrap();
+                editing.modify(() => {
+                    activeNotes.set(pitch, NoteEventBox.create(boxGraph, UUID.generate(), box => {
+                        box.position.setValue(position);
+                        box.duration.setValue(1.0);
+                        box.pitch.setValue(pitch);
+                        box.velocity.setValue(MidiData.readParam2(data) / 127.0);
+                        box.events.refer(collection.events);
+                    }));
+                }, false);
+            }
+            else if (MidiData.isNoteOff(data)) {
+                const pitch = MidiData.readParam1(data);
+                activeNotes.delete(pitch);
+            }
+        }));
+        return terminator;
+    };
+})(RecordMidi || (RecordMidi = {}));

package/dist/capture/RecordTrack.d.ts

@@ -0,0 +1,7 @@
+import { AudioUnitBox, TrackBox } from "@opendaw/studio-boxes";
+import { TrackType } from "@opendaw/studio-adapters";
+import { Editing } from "@opendaw/lib-box";
+export declare namespace RecordTrack {
+    const findOrCreate: (editing: Editing, audioUnitBox: AudioUnitBox, type: TrackType) => TrackBox;
+}
+//# sourceMappingURL=RecordTrack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordTrack.d.ts","sourceRoot":"","sources":["../../src/capture/RecordTrack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE5D,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAA;AAClD,OAAO,EAAC,OAAO,EAAC,MAAM,kBAAkB,CAAA;AAExC,yBAAiB,WAAW,CAAC;IAClB,MAAM,YAAY,GAAI,SAAS,OAAO,EAAE,cAAc,YAAY,EAAE,MAAM,SAAS,KAAG,QAe5F,CAAA;CACJ"}

package/dist/capture/RecordTrack.js

@@ -0,0 +1,23 @@
+import { TrackBox } from "@opendaw/studio-boxes";
+import { asInstanceOf, UUID } from "@opendaw/lib-std";
+export var RecordTrack;
+(function (RecordTrack) {
+    RecordTrack.findOrCreate = (editing, audioUnitBox, type) => {
+        let index = 0 | 0;
+        for (const trackBox of audioUnitBox.tracks.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, TrackBox))) {
+            const hasNoRegions = trackBox.regions.pointerHub.isEmpty();
+            const acceptsNotes = trackBox.type.getValue() === type;
+            if (hasNoRegions && acceptsNotes) {
+                return trackBox;
+            }
+            index = Math.max(index, trackBox.index.getValue());
+        }
+        return editing.modify(() => TrackBox.create(audioUnitBox.graph, UUID.generate(), box => {
+            box.type.setValue(type);
+            box.index.setValue(index + 1);
+            box.tracks.refer(audioUnitBox.tracks);
+            box.target.refer(audioUnitBox);
+        })).unwrap("Could not create TrackBox");
+    };
+})(RecordTrack || (RecordTrack = {}));

package/dist/capture/Recording.d.ts

@@ -0,0 +1,9 @@
+import { Terminable } from "@opendaw/lib-std";
+import { RecordingContext } from "./RecordingContext";
+export declare class Recording {
+    #private;
+    static get isRecording(): boolean;
+    static start(context: RecordingContext, countIn: boolean): Promise<Terminable>;
+    private constructor();
+}
+//# sourceMappingURL=Recording.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Recording.d.ts","sourceRoot":"","sources":["../../src/capture/Recording.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAE3F,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AAMnD,qBAAa,SAAS;;IAClB,MAAM,KAAK,WAAW,IAAI,OAAO,CAA2B;WAE/C,KAAK,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IA+DpF,OAAO;CACV"}

package/dist/capture/Recording.js

@@ -0,0 +1,65 @@
+import { asInstanceOf, assert, Option, Terminable, Terminator, warn } from "@opendaw/lib-std";
+import { Promises } from "@opendaw/lib-runtime";
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { InstrumentFactories } from "../InstrumentFactories";
+export class Recording {
+    static get isRecording() { return this.#isRecording; }
+    static async start(context, countIn) {
+        if (this.#isRecording) {
+            return Promise.resolve(Terminable.Empty);
+        }
+        this.#isRecording = true;
+        assert(this.#instance.isEmpty(), "Recording already in progress");
+        const { project } = context;
+        this.#prepare(project);
+        const { captureManager, engine, editing } = project;
+        const terminator = new Terminator();
+        const captures = captureManager.filterArmed();
+        if (captures.length === 0) {
+            this.#isRecording = false;
+            return warn("No track is armed for Recording");
+        }
+        const { status, error } = await Promises.tryCatch(Promise.all(captures.map(capture => capture.prepareRecording(context))));
+        if (status === "rejected") {
+            this.#isRecording = false;
+            return warn(`Could not prepare recording: ${error}`);
+        }
+        terminator.ownAll(...captures.map(capture => capture.startRecording(context)));
+        engine.startRecording(countIn);
+        const { isRecording, isCountingIn } = engine;
+        const stop = () => {
+            if (isRecording.getValue() || isCountingIn.getValue()) {
+                return;
+            }
+            editing.mark();
+            terminator.terminate();
+            this.#isRecording = false;
+        };
+        terminator.ownAll(engine.isRecording.subscribe(stop), engine.isCountingIn.subscribe(stop), Terminable.create(() => Recording.#instance = Option.None));
+        this.#instance = Option.wrap(new Recording());
+        return terminator;
+    }
+    static #prepare({ api, captureManager, editing, rootBox, userEditingManager }) {
+        const captures = captureManager.filterArmed();
+        const instruments = rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .filter(box => box.type.getValue() === AudioUnitType.Instrument);
+        if (instruments.length === 0) {
+            const { audioUnitBox } = editing
+                .modify(() => api.createInstrument(InstrumentFactories.Tape))
+                .unwrap("Could not create Tape");
+            captureManager.get(audioUnitBox.address.uuid)
+                .unwrap("Could not unwrap capture")
+                .armed.setValue(true);
+        }
+        else if (captures.length === 0) {
+            userEditingManager.audioUnit.get()
+                .ifSome(({ box: { address: { uuid } } }) => captureManager.get(uuid)
+                .ifSome(capture => capture.armed.setValue(true))); // auto arm editing audio-unit
+        }
+    }
+    static #isRecording = false;
+    static #instance = Option.None;
+    constructor() { }
+}