@opendaw/studio-core 0.0.18 → 0.0.20

package/dist/capture/CaptureAudio.js

@@ -0,0 +1,106 @@
+import { assert, isDefined, isUndefined, ObservableOption, Option, warn } from "@opendaw/lib-std";
+import { Capture } from "./Capture";
+import { RecordAudio } from "./RecordAudio";
+import { AudioInputDevices } from "../AudioInputDevices";
+import { Promises } from "@opendaw/lib-runtime";
+export class CaptureAudio extends Capture {
+    #stream;
+    #streamGenerator;
+    #requestChannels = Option.None;
+    #gainDb = 0.0;
+    constructor(manager, audioUnitBox, captureBox) {
+        super(manager, audioUnitBox, captureBox);
+        this.#stream = new ObservableOption();
+        this.#streamGenerator = Promises.sequential(() => this.#updateStream());
+        this.ownAll(captureBox.requestChannels.catchupAndSubscribe(owner => {
+            const channels = owner.getValue();
+            this.#requestChannels = channels === 1 || channels === 2 ? Option.wrap(channels) : Option.None;
+        }), captureBox.gainDb.catchupAndSubscribe(owner => this.#gainDb = owner.getValue()), captureBox.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, engine, 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;
+        return RecordAudio.start({
+            recordingWorklet: worklets.createRecording(channelCount, numChunks, audioContext.outputLatency),
+            mediaStream,
+            sampleManager,
+            audioContext,
+            engine,
+            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 AudioInputDevices.requestStream({
+            deviceId: { exact: deviceId },
+            sampleRate: this.manager.project.env.sampleRate,
+            sampleSize: 32,
+            echoCancellation: false,
+            noiseSuppression: false,
+            autoGainControl: false,
+            channelCount: { exact: 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);
+    prepareRecording({ requestMIDIAccess }: RecordingContext): Promise<void>;
+    startRecording({ project, engine }: RecordingContext): Terminable;
+    get deviceLabel(): Option<string>;
+}
+//# 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,EAAiD,MAAM,EAAS,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAG1G,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;AAE/C,qBAAa,WAAY,SAAQ,OAAO,CAAC,cAAc,CAAC;;gBAKxC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc;IAWzF,gBAAgB,CAAC,EAAC,iBAAiB,EAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5E,cAAc,CAAC,EAAC,OAAO,EAAE,MAAM,EAAC,EAAE,gBAAgB,GAAG,UAAU;IAyB/D,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,CAAqB;CACzD"}

package/dist/capture/CaptureMidi.js

@@ -0,0 +1,50 @@
+import { assert, isDefined, isUndefined, Notifier, Option, panic, Terminable } from "@opendaw/lib-std";
+import { Events } from "@opendaw/lib-dom";
+import { MidiData } from "@opendaw/lib-midi";
+import { Capture } from "./Capture";
+import { RecordMidi } from "./RecordMidi";
+export class CaptureMidi extends Capture {
+    #midiAccess = Option.None;
+    #filterChannel = Option.None;
+    constructor(manager, audioUnitBox, captureMidiBox) {
+        super(manager, audioUnitBox, captureMidiBox);
+        this.ownAll(captureMidiBox.channel.catchupAndSubscribe(owner => {
+            const channel = owner.getValue();
+            this.#filterChannel = channel >= 0 ? Option.wrap(channel) : Option.None;
+        }));
+    }
+    async prepareRecording({ requestMIDIAccess }) {
+        return requestMIDIAccess()
+            .then(midiAccess => {
+            const option = this.deviceId.getValue();
+            if (option.nonEmpty()) {
+                const captureDevices = Array.from(midiAccess.inputs.values());
+                const id = option.unwrap();
+                if (isUndefined(captureDevices.find(device => id === device.id))) {
+                    return panic(`Could not find MIDI device with id: '${id}'`);
+                }
+            }
+            this.#midiAccess = Option.wrap(midiAccess);
+        });
+    }
+    startRecording({ project, engine }) {
+        assert(this.#midiAccess.nonEmpty(), "Stream not prepared.");
+        const midiAccess = this.#midiAccess.unwrap();
+        const notifier = new Notifier();
+        const captureDevices = Array.from(midiAccess.inputs.values());
+        this.deviceId.getValue().ifSome(id => captureDevices.filter(device => id === device.id));
+        return Terminable.many(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)) {
+                notifier.notify(event);
+            }
+        }))), RecordMidi.start({
+            notifier,
+            engine,
+            project,
+            capture: this
+        }));
+    }
+    get deviceLabel() { return Option.None; }
+}

package/dist/capture/RecordAudio.d.ts

@@ -0,0 +1,21 @@
+import { Terminable } from "@opendaw/lib-std";
+import { SampleManager } from "@opendaw/studio-adapters";
+import { Engine } from "../Engine";
+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;
+        engine: Engine;
+        project: Project;
+        capture: Capture;
+        gainDb: number;
+    };
+    export const start: ({ recordingWorklet, mediaStream, sampleManager, audioContext, engine, 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,MAAM,EAAC,MAAM,WAAW,CAAA;AAChC,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,MAAM,EAAE,MAAM,CAAA;QACd,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,kGAEG,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, engine, project, capture, gainDb }) => {
+        const terminator = new Terminator();
+        const beats = PPQN.fromSignature(1, project.timelineBox.signature.denominator.getValue());
+        const { editing, 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,15 @@
+import { Notifier, Terminable } from "@opendaw/lib-std";
+import { Engine } from "../Engine";
+import { Project } from "../Project";
+import { Capture } from "./Capture";
+export declare namespace RecordMidi {
+    type RecordMidiContext = {
+        notifier: Notifier<MIDIMessageEvent>;
+        engine: Engine;
+        project: Project;
+        capture: Capture;
+    };
+    export const start: ({ notifier, engine, 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,MAAM,EAAC,MAAM,WAAW,CAAA;AAChC,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,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GAAI,wCAAsC,iBAAiB,KAAG,UAiE/E,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, engine, 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(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 (!engine.isRecording.getValue()) {
+                return;
+            }
+            const data = event.data;
+            if (isUndefined(data)) {
+                return;
+            }
+            const position = 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 { engine, project } = context;
+        this.#prepare(project);
+        const { captureManager, 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() { }
+}

package/dist/capture/RecordingContext.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "@opendaw/lib-std";
+import { SampleManager } from "@opendaw/studio-adapters";
+import { Project } from "../Project";
+import { Engine } from "../Engine";
+import { Worklets } from "../Worklets";
+export interface RecordingContext {
+    project: Project;
+    worklets: Worklets;
+    engine: Engine;
+    audioContext: AudioContext;
+    sampleManager: SampleManager;
+    requestMIDIAccess: Provider<Promise<MIDIAccess>>;
+}
+//# sourceMappingURL=RecordingContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordingContext.d.ts","sourceRoot":"","sources":["../../src/capture/RecordingContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAA;AACtD,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAA;AAChC,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAA;AAEpC,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,QAAQ,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,YAAY,CAAA;IAC1B,aAAa,EAAE,aAAa,CAAA;IAC5B,iBAAiB,EAAE,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAA;CACnD"}

package/dist/capture/RecordingContext.js

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

package/dist/dawproject/AudioUnitExportLayout.d.ts

@@ -0,0 +1,10 @@
+import { AudioUnitBox } from "@opendaw/studio-boxes";
+export declare namespace AudioUnitExportLayout {
+    interface Track {
+        audioUnit: AudioUnitBox;
+        children: Array<Track>;
+    }
+    const layout: (audioUnits: ReadonlyArray<AudioUnitBox>) => Array<Track>;
+    const printTrackStructure: (tracks: ReadonlyArray<Track>, indent?: number) => void;
+}
+//# sourceMappingURL=AudioUnitExportLayout.d.ts.map

package/dist/dawproject/AudioUnitExportLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitExportLayout.d.ts","sourceRoot":"","sources":["../../src/dawproject/AudioUnitExportLayout.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAC,MAAM,uBAAuB,CAAA;AAK/D,yBAAiB,qBAAqB,CAAC;IACnC,UAAiB,KAAK;QAClB,SAAS,EAAE,YAAY,CAAA;QACvB,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;KACzB;IAEM,MAAM,MAAM,GAAI,YAAY,aAAa,CAAC,YAAY,CAAC,KAAG,KAAK,CAAC,KAAK,CAgC3E,CAAA;IAgBM,MAAM,mBAAmB,GAAI,QAAQ,aAAa,CAAC,KAAK,CAAC,EAAE,eAAU,KAAG,IAU9E,CAAA;CACJ"}

package/dist/dawproject/AudioUnitExportLayout.js

@@ -0,0 +1,64 @@
+import { AudioBusBox, AudioUnitBox } from "@opendaw/studio-boxes";
+import { ArrayMultimap, asInstanceOf, isDefined, isInstanceOf, Option } from "@opendaw/lib-std";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { DeviceBoxUtils } from "@opendaw/studio-adapters";
+export var AudioUnitExportLayout;
+(function (AudioUnitExportLayout) {
+    AudioUnitExportLayout.layout = (audioUnits) => {
+        const feedsInto = new ArrayMultimap();
+        audioUnits.forEach(unit => {
+            unit.output.targetVertex.ifSome(({ box }) => {
+                if (isInstanceOf(box, AudioBusBox)) {
+                    box.output.targetVertex.ifSome(({ box: targetUnit }) => {
+                        const audioUnit = asInstanceOf(targetUnit, AudioUnitBox);
+                        if (audioUnit.type.getValue() !== AudioUnitType.Output) {
+                            feedsInto.add(audioUnit, unit);
+                        }
+                    });
+                }
+            });
+        });
+        // Roots are:
+        // 1. Units with no output
+        // 2. Units that connect directly to Output (become independent roots)
+        // 3. The Output unit itself (as a standalone root)
+        const roots = audioUnits.filter(unit => {
+            if (unit.type.getValue() === AudioUnitType.Output) {
+                return true;
+            }
+            if (unit.output.targetVertex.isEmpty()) {
+                return true;
+            }
+            return unit.output.targetVertex
+                .flatMap(({ box }) => isInstanceOf(box, AudioBusBox) ? box.output.targetVertex : Option.None)
+                .map(({ box }) => asInstanceOf(box, AudioUnitBox).type.getValue() === AudioUnitType.Output)
+                .unwrapOrElse(false);
+        });
+        const visited = new Set();
+        return roots
+            .map(root => buildTrackRecursive(root, feedsInto, visited))
+            .filter(isDefined);
+    };
+    const buildTrackRecursive = (audioUnit, feedsInto, visited) => {
+        if (visited.has(audioUnit)) {
+            console.warn(`Cycle detected at AudioUnitBox`, audioUnit);
+            return null;
+        }
+        visited.add(audioUnit);
+        const children = feedsInto.get(audioUnit)
+            .map(childUnit => buildTrackRecursive(childUnit, feedsInto, visited))
+            .filter(isDefined);
+        return { audioUnit, children };
+    };
+    AudioUnitExportLayout.printTrackStructure = (tracks, indent = 0) => {
+        const spaces = " ".repeat(indent);
+        tracks.forEach(track => {
+            const inputBox = track.audioUnit.input.pointerHub.incoming().at(0)?.box;
+            const label = DeviceBoxUtils.lookupLabelField(inputBox).getValue();
+            console.debug(`${spaces}⌙ ${label} (${track.audioUnit.address.toString()})`);
+            if (track.children.length > 0) {
+                AudioUnitExportLayout.printTrackStructure(track.children, indent + 2);
+            }
+        });
+    };
+})(AudioUnitExportLayout || (AudioUnitExportLayout = {}));