@opendaw/studio-core 0.0.19 → 0.0.20

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 = {}));

package/dist/dawproject/BuiltinDevices.d.ts

@@ -0,0 +1,9 @@
+import { EqualizerSchema } from "@opendaw/lib-dawproject";
+import { RevampDeviceBox } from "@opendaw/studio-boxes";
+import { BoxGraph, Field } from "@opendaw/lib-box";
+import { int } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+export declare namespace BuiltinDevices {
+    const equalizer: (boxGraph: BoxGraph, equalizer: EqualizerSchema, field: Field<Pointers.MidiEffectHost> | Field<Pointers.AudioEffectHost>, index: int) => RevampDeviceBox;
+}
+//# sourceMappingURL=BuiltinDevices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BuiltinDevices.d.ts","sourceRoot":"","sources":["../../src/dawproject/BuiltinDevices.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAmB,MAAM,yBAAyB,CAAA;AACjG,OAAO,EAAC,eAAe,EAA0B,MAAM,uBAAuB,CAAA;AAC9E,OAAO,EAAC,QAAQ,EAAE,KAAK,EAAC,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAY,GAAG,EAAO,MAAM,kBAAkB,CAAA;AACrD,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAG9C,yBAAiB,cAAc,CAAC;IACrB,MAAM,SAAS,GAAI,UAAU,QAAQ,EAClB,WAAW,eAAe,EAC1B,OAAO,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,EACvE,OAAO,GAAG,KAAG,eA4DtC,CAAA;CACJ"}

package/dist/dawproject/BuiltinDevices.js

@@ -0,0 +1,70 @@
+import { EqBandType, ParameterDecoder } from "@opendaw/lib-dawproject";
+import { RevampDeviceBox } from "@opendaw/studio-boxes";
+import { ifDefined, UUID } from "@opendaw/lib-std";
+import { semitoneToHz } from "@opendaw/lib-dsp";
+export var BuiltinDevices;
+(function (BuiltinDevices) {
+    BuiltinDevices.equalizer = (boxGraph, equalizer, field, index) => {
+        const mapOrder = (order) => {
+            switch (order) {
+                case 1:
+                case 2:
+                    return 0;
+                case 3:
+                case 4:
+                    return 1;
+                case 5:
+                case 6:
+                    return 2;
+                default:
+                    return 3;
+            }
+        };
+        const readPass = (schema, pass) => {
+            const { order, frequency, q, enabled } = pass;
+            order.setValue(mapOrder(schema.order));
+            frequency.setValue(semitoneToHz(schema.freq.value));
+            ifDefined(schema.Q?.value, value => q.setValue(value));
+            ifDefined(schema.enabled?.value, value => enabled.setValue(value));
+        };
+        const readShelf = (schema, pass) => {
+            const { frequency, gain, enabled } = pass;
+            frequency.setValue(ParameterDecoder.readValue(schema.freq));
+            ifDefined(schema.gain?.value, value => gain.setValue(value));
+            ifDefined(schema.enabled?.value, value => enabled.setValue(value));
+        };
+        return RevampDeviceBox.create(boxGraph, UUID.generate(), box => {
+            box.host.refer(field);
+            box.index.setValue(index);
+            box.label.setValue(equalizer.deviceName ?? "Revamp");
+            let bellIndex = 0;
+            equalizer.bands.forEach((band) => {
+                switch (band.type) {
+                    case EqBandType.HIGH_PASS:
+                        return readPass(band, box.highPass);
+                    case EqBandType.LOW_PASS:
+                        return readPass(band, box.lowPass);
+                    case EqBandType.HIGH_SHELF:
+                        return readShelf(band, box.highShelf);
+                    case EqBandType.LOW_SHELF:
+                        return readShelf(band, box.lowShelf);
+                    case EqBandType.BELL: {
+                        if (bellIndex === 3) {
+                            return;
+                        }
+                        const bell = [box.lowBell, box.midBell, box.highBell][bellIndex++];
+                        const { frequency, gain, q, enabled } = bell;
+                        frequency.setValue(ParameterDecoder.readValue(band.freq));
+                        ifDefined(band.Q?.value, value => q.setValue(value));
+                        ifDefined(band.gain?.value, value => gain.setValue(value));
+                        ifDefined(band.enabled?.value, value => enabled.setValue(value));
+                        return;
+                    }
+                    default:
+                        console.warn(`Cannot map band type: ${band.type} to Revamp`);
+                        return;
+                }
+            });
+        });
+    };
+})(BuiltinDevices || (BuiltinDevices = {}));

package/dist/dawproject/{DawProjectIO.d.ts → DawProject.d.ts}

@@ -1,20 +1,22 @@
 import { UUID } from "@opendaw/lib-std";
 import { MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
-export declare namespace DawProjectIO {
+import { Project } from "../Project";
+export declare namespace DawProject {
     type Resource = {
         uuid: UUID.Format;
         path: string;
         name: string;
         buffer: ArrayBuffer;
     };
-    interface Resources {
+    interface ResourceProvider {
         fromPath(path: string): Resource;
         fromUUID(uuid: UUID.Format): Resource;
     }
     const decode: (buffer: ArrayBuffer | NonSharedBuffer) => Promise<{
         metaData: MetaDataSchema;
         project: ProjectSchema;
-        resources: Resources;
+        resources: ResourceProvider;
     }>;
+    const encode: (project: Project, metaData: MetaDataSchema) => Promise<ArrayBuffer>;
 }
-//# sourceMappingURL=DawProjectIO.d.ts.map
+//# sourceMappingURL=DawProject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,IAAI,EAAC,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAsB,cAAc,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAC1F,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAGlC,yBAAiB,UAAU,CAAC;IACxB,KAAY,QAAQ,GAAG;QAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAA;IAE7F,UAAiB,gBAAgB;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;QAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAA;KACxC;IAEM,MAAM,MAAM,GAAU,QAAQ,WAAW,GAAG,eAAe,KAAG,OAAO,CAAC;QACzE,QAAQ,EAAE,cAAc,CAAC;QACzB,OAAO,EAAE,aAAa,CAAC;QACvB,SAAS,EAAE,gBAAgB,CAAA;KAC9B,CAyBA,CAAA;IAEM,MAAM,MAAM,GAAI,SAAS,OAAO,EAAE,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAgBtF,CAAA;CACJ"}