@opendaw/studio-core 0.0.22 → 0.0.24

package/dist/capture/RecordAudio.js

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

package/dist/capture/RecordMidi.d.ts

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

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

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

package/dist/capture/RecordMidi.js

@@ -1,8 +1,7 @@
-import { isUndefined, Option, quantizeCeil, quantizeFloor, Terminator, UUID } from "@opendaw/lib-std";
+import { 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 { NoteSignal, TrackType } from "@opendaw/studio-adapters";
 import { RecordTrack } from "./RecordTrack";
 import { ColorCodes } from "../ColorCodes";
 export var RecordMidi;
@@ -10,12 +9,13 @@ export var 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 { editing, boxGraph, engine } = project;
+        const { position, isRecording } = engine;
         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 => {
+        terminator.own(position.catchupAndSubscribe(owner => {
             if (writing.isEmpty()) {
                 return;
             }
@@ -29,7 +29,7 @@ export var RecordMidi;
                     loopDuration.setValue(newDuration);
                     for (const event of activeNotes.values()) {
                         if (event.isAttached()) {
-                            event.duration.setValue(writePosition - event.position.getValue());
+                            event.duration.setValue(writePosition - region.position.getValue() - event.position.getValue());
                         }
                         else {
                             activeNotes.delete(event.pitch.getValue());
@@ -37,47 +37,44 @@ export var RecordMidi;
                     }
                 }
                 else {
+                    terminator.terminate();
                     writing = Option.None;
                 }
             }, false);
         }));
-        terminator.ownAll(notifier.subscribe((event) => {
-            if (!project.engine.isRecording.getValue()) {
+        terminator.ownAll(notifier.subscribe((signal) => {
+            if (!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);
+            const ppqn = position.getValue();
+            if (NoteSignal.isOn(signal)) {
+                const { pitch, velocity } = signal;
                 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.position.setValue(quantizeFloor(ppqn, beats));
                             box.hue.setValue(ColorCodes.forTrackType(TrackType.Notes));
                         });
+                        engine.ignoreNoteRegion(region.address.uuid);
                         writing = Option.wrap({ region, collection });
                     }, false);
                 }
-                const { collection } = writing.unwrap();
+                const { region, collection } = writing.unwrap();
                 editing.modify(() => {
                     activeNotes.set(pitch, NoteEventBox.create(boxGraph, UUID.generate(), box => {
-                        box.position.setValue(position);
+                        box.position.setValue(ppqn - region.position.getValue());
                         box.duration.setValue(1.0);
                         box.pitch.setValue(pitch);
-                        box.velocity.setValue(MidiData.readParam2(data) / 127.0);
+                        box.velocity.setValue(velocity);
                         box.events.refer(collection.events);
                     }));
                 }, false);
             }
-            else if (MidiData.isNoteOff(data)) {
-                const pitch = MidiData.readParam1(data);
-                activeNotes.delete(pitch);
+            else if (NoteSignal.isOff(signal)) {
+                activeNotes.delete(signal.pitch);
             }
         }));
         return terminator;

package/dist/capture/Recording.d.ts

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

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

@@ -1 +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"}
+{"version":3,"file":"Recording.d.ts","sourceRoot":"","sources":["../../src/capture/Recording.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAK3F,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAE1C,qBAAa,SAAS;;IAClB,MAAM,KAAK,WAAW,IAAI,OAAO,CAA2B;WAE/C,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IA8D3E,OAAO;CACV"}

package/dist/capture/Recording.js

@@ -5,27 +5,26 @@ import { AudioUnitType } from "@opendaw/studio-enums";
 import { InstrumentFactories } from "../InstrumentFactories";
 export class Recording {
     static get isRecording() { return this.#isRecording; }
-    static async start(context, countIn) {
+    static async start(project, 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 { captureDevices, engine, editing } = project;
         const terminator = new Terminator();
-        const captures = captureManager.filterArmed();
+        const captures = captureDevices.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))));
+        const { status, error } = await Promises.tryCatch(Promise.all(captures.map(capture => capture.prepareRecording())));
         if (status === "rejected") {
             this.#isRecording = false;
-            return warn(`Could not prepare recording: ${error}`);
+            return warn(String(error));
         }
-        terminator.ownAll(...captures.map(capture => capture.startRecording(context)));
+        terminator.ownAll(...captures.map(capture => capture.startRecording()));
         engine.startRecording(countIn);
         const { isRecording, isCountingIn } = engine;
         const stop = () => {
@@ -40,8 +39,8 @@ export class Recording {
         this.#instance = Option.wrap(new Recording());
         return terminator;
     }
-    static #prepare({ api, captureManager, editing, rootBox, userEditingManager }) {
-        const captures = captureManager.filterArmed();
+    static #prepare({ api, captureDevices, editing, rootBox, userEditingManager }) {
+        const captures = captureDevices.filterArmed();
         const instruments = rootBox.audioUnits.pointerHub.incoming()
             .map(({ box }) => asInstanceOf(box, AudioUnitBox))
             .filter(box => box.type.getValue() === AudioUnitType.Instrument);
@@ -49,13 +48,13 @@ export class Recording {
             const { audioUnitBox } = editing
                 .modify(() => api.createInstrument(InstrumentFactories.Tape))
                 .unwrap("Could not create Tape");
-            captureManager.get(audioUnitBox.address.uuid)
+            captureDevices.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(({ box: { address: { uuid } } }) => captureDevices.get(uuid)
                 .ifSome(capture => capture.armed.setValue(true))); // auto arm editing audio-unit
         }
     }

package/dist/dawproject/DawProject.d.ts

@@ -1,6 +1,6 @@
 import { UUID } from "@opendaw/lib-std";
 import { MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
-import { Project } from "../Project";
+import { Project } from "../project/Project";
 export declare namespace DawProject {
     type Resource = {
         uuid: UUID.Format;

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

@@ -1 +1 @@
-{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAEA,OAAO,EAA8B,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAClE,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,CAwBA,CAAA;IAEM,MAAM,MAAM,GAAI,SAAS,OAAO,EAAE,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAgBtF,CAAA;CACJ"}
+{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAClE,OAAO,EAAsB,cAAc,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAC1F,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAG1C,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,GAAU,SAAS,OAAO,EAAE,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAiB5F,CAAA;CACJ"}

package/dist/dawproject/DawProject.js

@@ -1,4 +1,3 @@
-import JSZip from "jszip";
 import { Xml } from "@opendaw/lib-xml";
 import { asDefined, isDefined, panic, UUID } from "@opendaw/lib-std";
 import { FileReferenceSchema, MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
@@ -6,6 +5,7 @@ import { DawProjectExporter } from "./DawProjectExporter";
 export var DawProject;
 (function (DawProject) {
     DawProject.decode = async (buffer) => {
+        const { default: JSZip } = await import("jszip");
         const zip = await JSZip.loadAsync(buffer);
         const metaDataXml = await zip.file("metadata.xml")?.async("string");
         const metaData = isDefined(metaDataXml) ? Xml.parse(metaDataXml, MetaDataSchema) : Xml.element({}, MetaDataSchema);
@@ -28,7 +28,8 @@ export var DawProject;
             }
         };
     };
-    DawProject.encode = (project, metaData) => {
+    DawProject.encode = async (project, metaData) => {
+        const { default: JSZip } = await import("jszip");
         const zip = new JSZip();
         const projectSchema = DawProjectExporter.write(project, {
             write: (path, buffer) => {

package/dist/dawproject/DawProjectExporter.d.ts

@@ -1,5 +1,5 @@
 import { FileReferenceSchema, ProjectSchema } from "@opendaw/lib-dawproject";
-import { Project } from "../Project";
+import { Project } from "../project/Project";
 export declare namespace DawProjectExporter {
     interface ResourcePacker {
         write(path: string, buffer: ArrayBufferLike): FileReferenceSchema;

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

@@ -1 +1 @@
-{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AAGA,OAAO,EAaH,mBAAmB,EAKnB,aAAa,EAUhB,MAAM,yBAAyB,CAAA;AAchC,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAQlC,yBAAiB,kBAAkB,CAAC;IAChC,UAAiB,cAAc;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,mBAAmB,CAAA;KAAC;IAE5F,MAAM,KAAK,GAAI,SAAS,OAAO,EAAE,gBAAgB,cAAc,kBA4PrE,CAAA;CACJ"}
+{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AAGA,OAAO,EAaH,mBAAmB,EAKnB,aAAa,EAUhB,MAAM,yBAAyB,CAAA;AAchC,OAAO,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAA;AAQ1C,yBAAiB,kBAAkB,CAAC;IAChC,UAAiB,cAAc;QAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,mBAAmB,CAAA;KAAC;IAE5F,MAAM,KAAK,GAAI,SAAS,OAAO,EAAE,gBAAgB,cAAc,kBA4PrE,CAAA;CACJ"}

package/dist/dawproject/DawProjectExporter.test.js

@@ -2,8 +2,8 @@ import { describe, it } from "vitest";
 import { fileURLToPath } from "url";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { Project } from "../Project";
-import { Option, panic, Terminable } from "@opendaw/lib-std";
+import { Project } from "../project/Project";
+import { InaccessibleProperty, Option, panic, Terminable } from "@opendaw/lib-std";
 import { Xml } from "@opendaw/lib-xml";
 import { FileReferenceSchema } from "@opendaw/lib-dawproject";
 import { DawProjectExporter } from "./DawProjectExporter";
@@ -14,6 +14,8 @@ describe("DawProjectExport", () => {
         const buffer = fs.readFileSync(path.join(__dirname, projectPath));
         const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
         const project = Project.load({
+            audioContext: InaccessibleProperty,
+            audioWorklets: InaccessibleProperty,
             sampleManager: new class {
                 record(_loader) {
                     throw new Error("Method not implemented.");
@@ -31,9 +33,8 @@ describe("DawProjectExport", () => {
                         }
                     };
                 }
-                invalidate(_uuid) {
-                    return panic("Method not implemented.");
-                }
+                remove(_uuid) { return panic("Method not implemented."); }
+                invalidate(_uuid) { return panic("Method not implemented."); }
             }
         }, arrayBuffer);
         const schema = DawProjectExporter.write(project, {

package/dist/index.d.ts

@@ -8,13 +8,19 @@ export * from "./samples/SampleProvider";
 export * from "./capture/Capture";
 export * from "./capture/CaptureAudio";
 export * from "./capture/CaptureMidi";
-export * from "./capture/CaptureManager";
+export * from "./capture/CaptureDevices";
 export * from "./capture/Recording";
-export * from "./capture/RecordingContext";
 export * from "./dawproject/DawProject";
 export * from "./dawproject/DawProjectExporter";
 export * from "./dawproject/DawProjectImport";
 export * from "./dawproject/DawProjectImport";
+export * from "./project/Project";
+export * from "./project/ProjectApi";
+export * from "./project/ProjectBundle";
+export * from "./project/ProjectEnv";
+export * from "./project/ProjectMeta";
+export * from "./project/ProjectPaths";
+export * from "./project/ProjectProfile";
 export * from "./AudioDevices";
 export * from "./AudioUnitOrdering";
 export * from "./ColorCodes";
@@ -33,10 +39,8 @@ export * from "./InstrumentProduct";
 export * from "./MeterWorklet";
 export * from "./MidiDevices";
 export * from "./Mixer";
-export * from "./Project";
-export * from "./ProjectApi";
-export * from "./ProjectEnv";
+export * from "./PeaksWriter";
 export * from "./Wav";
 export * from "./WorkerAgents";
-export * from "./Worklets";
+export * from "./AudioWorklets";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAE1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,+BAA+B,CAAA;AAE7C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AAExC,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,mCAAmC,CAAA;AACjD,cAAc,0BAA0B,CAAA;AAExC,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,qBAAqB,CAAA;AAEnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,+BAA+B,CAAA;AAE7C,cAAc,mBAAmB,CAAA;AACjC,cAAc,sBAAsB,CAAA;AACpC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AAExC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,eAAe,CAAA;AAC7B,cAAc,OAAO,CAAA;AACrB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA"}

package/dist/index.js

@@ -8,13 +8,19 @@ export * from "./samples/SampleProvider";
 export * from "./capture/Capture";
 export * from "./capture/CaptureAudio";
 export * from "./capture/CaptureMidi";
-export * from "./capture/CaptureManager";
+export * from "./capture/CaptureDevices";
 export * from "./capture/Recording";
-export * from "./capture/RecordingContext";
 export * from "./dawproject/DawProject";
 export * from "./dawproject/DawProjectExporter";
 export * from "./dawproject/DawProjectImport";
 export * from "./dawproject/DawProjectImport";
+export * from "./project/Project";
+export * from "./project/ProjectApi";
+export * from "./project/ProjectBundle";
+export * from "./project/ProjectEnv";
+export * from "./project/ProjectMeta";
+export * from "./project/ProjectPaths";
+export * from "./project/ProjectProfile";
 export * from "./AudioDevices";
 export * from "./AudioUnitOrdering";
 export * from "./ColorCodes";
@@ -33,9 +39,7 @@ export * from "./InstrumentProduct";
 export * from "./MeterWorklet";
 export * from "./MidiDevices";
 export * from "./Mixer";
-export * from "./Project";
-export * from "./ProjectApi";
-export * from "./ProjectEnv";
+export * from "./PeaksWriter";
 export * from "./Wav";
 export * from "./WorkerAgents";
-export * from "./Worklets";
+export * from "./AudioWorklets";