@opendaw/studio-core 0.0.82 → 0.0.84

package/dist/ExternalLib.d.ts

@@ -1,5 +1,6 @@
+import { Promises } from "@opendaw/lib-runtime";
 export declare namespace ExternalLib {
-    const JSZip: () => Promise<import("jszip")>;
-    const SoundFont2: () => Promise<typeof import("soundfont2").SoundFont2>;
+    const JSZip: () => Promise<Promises.RejectedResult | Promises.ResolveResult<import("jszip")>>;
+    const SoundFont2: () => Promise<Promises.RejectedResult | Promises.ResolveResult<typeof import("soundfont2").SoundFont2>>;
 }
 //# sourceMappingURL=ExternalLib.d.ts.map

package/dist/ExternalLib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExternalLib.d.ts","sourceRoot":"","sources":["../src/ExternalLib.ts"],"names":[],"mappings":"AAGA,yBAAiB,WAAW,CAAC;IAMlB,MAAM,KAAK,gCAC8C,CAAA;IAEzD,MAAM,UAAU,uDAC+C,CAAA;CACzE"}
+{"version":3,"file":"ExternalLib.d.ts","sourceRoot":"","sources":["../src/ExternalLib.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAA;AAG7C,yBAAiB,WAAW,CAAC;IAMlB,MAAM,KAAK,kFAC+C,CAAA;IAE1D,MAAM,UAAU,yGACgD,CAAA;CAC1E"}

package/dist/ExternalLib.js

@@ -5,6 +5,6 @@ export var ExternalLib;
         console.debug(`ExternalLib.importFailure count: ${count}, online: ${navigator.onLine}`, error);
         return count < 10;
     };
-    ExternalLib.JSZip = async () => await Promises.guardedRetry(() => import("jszip").then(({ default: JSZip }) => JSZip), callback);
-    ExternalLib.SoundFont2 = async () => await Promises.guardedRetry(() => import("soundfont2").then(({ SoundFont2 }) => SoundFont2), callback);
+    ExternalLib.JSZip = async () => await Promises.tryCatch(Promises.guardedRetry(() => import("jszip").then(({ default: JSZip }) => JSZip), callback));
+    ExternalLib.SoundFont2 = async () => await Promises.tryCatch(Promises.guardedRetry(() => import("soundfont2").then(({ SoundFont2 }) => SoundFont2), callback));
 })(ExternalLib || (ExternalLib = {}));

package/dist/Preferences.d.ts

@@ -2,6 +2,8 @@ import { z } from "zod";
 import { Observer, Subscription } from "@opendaw/lib-std";
 declare const PreferencesSchema: z.ZodObject<{
     "visible-help-hints": z.ZodDefault<z.ZodBoolean>;
+    "note-audition-while-editing": z.ZodDefault<z.ZodBoolean>;
+    "modifying-controls-wheel": z.ZodDefault<z.ZodBoolean>;
     "auto-open-clips": z.ZodDefault<z.ZodBoolean>;
     "auto-create-output-compressor": z.ZodDefault<z.ZodBoolean>;
     "footer-show-fps-meter": z.ZodDefault<z.ZodBoolean>;
@@ -13,6 +15,8 @@ export type Preferences = z.infer<typeof PreferencesSchema>;
 export declare const Preferences: {
     values: {
         "visible-help-hints": boolean;
+        "note-audition-while-editing": boolean;
+        "modifying-controls-wheel": boolean;
         "auto-open-clips": boolean;
         "auto-create-output-compressor": boolean;
         "footer-show-fps-meter": boolean;

package/dist/Preferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Preferences.d.ts","sourceRoot":"","sources":["../src/Preferences.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAA;AACrB,OAAO,EAAsB,QAAQ,EAAE,YAAY,EAAW,MAAM,kBAAkB,CAAA;AAEtF,QAAA,MAAM,iBAAiB;;;;;;;;iBAQrB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,WAAW;;;;;;;;;;0BAkCM,GAAG,SAAS,MAAM,WAAW,YACrC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,YAAY,GAAG,KAAG,YAAY;CAK1E,CAAA"}
+{"version":3,"file":"Preferences.d.ts","sourceRoot":"","sources":["../src/Preferences.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAA;AACrB,OAAO,EAAsB,QAAQ,EAAE,YAAY,EAAW,MAAM,kBAAkB,CAAA;AAEtF,QAAA,MAAM,iBAAiB;;;;;;;;;;iBAUrB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,WAAW;;;;;;;;;;;;0BAkCM,GAAG,SAAS,MAAM,WAAW,YACrC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,YAAY,GAAG,KAAG,YAAY;CAK1E,CAAA"}

package/dist/Preferences.js

@@ -2,12 +2,14 @@ import { z } from "zod";
 import { isDefined, Notifier, tryCatch } from "@opendaw/lib-std";
 const PreferencesSchema = z.object({
     "visible-help-hints": z.boolean().default(true),
-    "auto-open-clips": z.boolean().default(false),
+    "note-audition-while-editing": z.boolean().default(true),
+    "modifying-controls-wheel": z.boolean().default(false),
+    "auto-open-clips": z.boolean().default(true),
     "auto-create-output-compressor": z.boolean().default(true),
     "footer-show-fps-meter": z.boolean().default(false),
     "footer-show-build-infos": z.boolean().default(false),
     "dragging-use-pointer-lock": z.boolean().default(false),
-    "enable-beta-features": z.boolean().default(false),
+    "enable-beta-features": z.boolean().default(false)
 });
 export const Preferences = (() => {
     const STORAGE_KEY = "preferences";

package/dist/capture/CaptureDevices.js

@@ -31,7 +31,7 @@ export class CaptureDevices {
             },
             onRemoved: ({ box: { address: { uuid } } }) => {
                 this.#captures.removeByKeyIfExist(uuid)?.terminate();
-                this.#captureSubscriptions.get(uuid).subscription.terminate();
+                this.#captureSubscriptions.removeByKeyIfExist(uuid)?.subscription.terminate();
             }
         });
     }

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

@@ -1 +1 @@
-{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGvG,OAAO,EAAa,mBAAmB,EAAY,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,mBAAmB,CAAA;QAClC,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,0FAAwF,kBAAkB,KACxG,UAwEL,CAAA;;CACJ"}
+{"version":3,"file":"RecordAudio.d.ts","sourceRoot":"","sources":["../../src/capture/RecordAudio.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAUzF,OAAO,EAAa,mBAAmB,EAAY,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,yBAAiB,WAAW,CAAC;IACzB,KAAK,kBAAkB,GAAG;QACtB,gBAAgB,EAAE,gBAAgB,CAAA;QAClC,WAAW,EAAE,WAAW,CAAA;QACxB,aAAa,EAAE,mBAAmB,CAAA;QAClC,YAAY,EAAE,YAAY,CAAA;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACjB,CAAA;IAED,MAAM,CAAC,MAAM,KAAK,GACd,0FAAwF,kBAAkB,KACxG,UAuFL,CAAA;;CACJ"}

package/dist/capture/RecordAudio.js

@@ -1,6 +1,6 @@
-import { Option, quantizeCeil, quantizeFloor, Terminable, Terminator, UUID } from "@opendaw/lib-std";
-import { dbToGain, PPQN } from "@opendaw/lib-dsp";
-import { AudioFileBox, AudioRegionBox, ValueEventCollectionBox } from "@opendaw/studio-boxes";
+import { Option, quantizeFloor, Terminable, Terminator, UUID } from "@opendaw/lib-std";
+import { dbToGain, PPQN, TimeBase } from "@opendaw/lib-dsp";
+import { AudioFileBox, AudioPitchStretchBox, AudioRegionBox, ValueEventCollectionBox, WarpMarkerBox } from "@opendaw/studio-boxes";
 import { ColorCodes, TrackType } from "@opendaw/studio-adapters";
 import { RecordTrack } from "./RecordTrack";
 export var RecordAudio;
@@ -31,15 +31,21 @@ export var RecordAudio;
             const fileName = `Recording-${fileDateString}`;
             const fileBox = AudioFileBox.create(boxGraph, uuid, box => box.fileName.setValue(fileName));
             const collectionBox = ValueEventCollectionBox.create(boxGraph, UUID.generate());
+            const stretchBox = AudioPitchStretchBox.create(boxGraph, UUID.generate());
+            WarpMarkerBox.create(boxGraph, UUID.generate(), box => box.owner.refer(stretchBox.warpMarkers));
+            const warpMarkerBox = WarpMarkerBox.create(boxGraph, UUID.generate(), box => box.owner.refer(stretchBox.warpMarkers));
             const regionBox = AudioRegionBox.create(boxGraph, UUID.generate(), box => {
                 box.file.refer(fileBox);
                 box.events.refer(collectionBox.owners);
                 box.regions.refer(trackBox.regions);
                 box.position.setValue(position);
                 box.hue.setValue(ColorCodes.forTrackType(TrackType.Audio));
+                box.timeBase.setValue(TimeBase.Musical);
                 box.label.setValue("Recording");
+                box.playMode.refer(stretchBox);
             });
-            return { fileBox, regionBox };
+            project.selection.select(regionBox);
+            return { fileBox, regionBox, warpMarkerBox };
         });
         const { tempoMap, env: { audioContext: { sampleRate } } } = project;
         terminator.ownAll(Terminable.create(() => {
@@ -61,15 +67,18 @@ export var RecordAudio;
                 streamGain.connect(recordingWorklet);
                 recordingData = createRecordingData(quantizeFloor(owner.getValue(), beats));
             }
-            const { regionBox } = recordingData.unwrap();
+            const { regionBox, warpMarkerBox } = recordingData.unwrap();
             editing.modify(() => {
                 if (regionBox.isAttached()) {
                     const { duration, loopDuration } = regionBox;
-                    const newDuration = quantizeCeil(engine.position.getValue(), beats) - regionBox.position.getValue();
-                    duration.setValue(newDuration);
-                    loopDuration.setValue(newDuration);
-                    const totalSamples = Math.ceil(tempoMap.intervalToSeconds(0, newDuration) * sampleRate);
+                    const distanceInPPQN = Math.floor(engine.position.getValue() - regionBox.position.getValue());
+                    duration.setValue(distanceInPPQN);
+                    loopDuration.setValue(distanceInPPQN);
+                    warpMarkerBox.position.setValue(distanceInPPQN);
+                    const seconds = tempoMap.intervalToSeconds(0, distanceInPPQN);
+                    const totalSamples = Math.ceil(seconds * sampleRate);
                     recordingWorklet.setFillLength(totalSamples);
+                    warpMarkerBox.seconds.setValue(seconds);
                 }
                 else {
                     terminator.terminate();

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,EAAO,QAAQ,EAAuC,UAAU,EAAmB,MAAM,kBAAkB,CAAA;AAGlH,OAAO,EAAa,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAC1E,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,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;IAID,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAuEvE,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,EAAa,UAAU,EAAY,MAAM,0BAA0B,CAAA;AAC1E,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AAGjC,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;IAID,MAAM,CAAC,MAAM,KAAK,GAAI,gCAA8B,iBAAiB,KAAG,UAwEvE,CAAA;;CACJ"}

package/dist/capture/RecordMidi.js

@@ -19,14 +19,15 @@ export var RecordMidi;
             const writePosition = position.getValue() + latency;
             editing.modify(() => {
                 const collection = NoteEventCollectionBox.create(boxGraph, UUID.generate());
-                const region = NoteRegionBox.create(boxGraph, UUID.generate(), box => {
+                const regionBox = NoteRegionBox.create(boxGraph, UUID.generate(), box => {
                     box.regions.refer(trackBox.regions);
                     box.events.refer(collection.owners);
                     box.position.setValue(Math.max(quantizeRound(writePosition, beats), 0));
                     box.hue.setValue(ColorCodes.forTrackType(TrackType.Notes));
                 });
-                engine.ignoreNoteRegion(region.address.uuid);
-                writing = Option.wrap({ region, collection });
+                project.selection.select(regionBox);
+                engine.ignoreNoteRegion(regionBox.address.uuid);
+                writing = Option.wrap({ region: regionBox, collection });
             }, false);
         };
         terminator.own(position.catchupAndSubscribe(owner => {

package/dist/dawproject/BuiltinDevices.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAElE,OAAO,EAAsB,cAAc,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAC1F,OAAO,EAAC,eAAe,EAAE,mBAAmB,EAAC,MAAM,0BAA0B,CAAA;AAI7E,yBAAiB,UAAU,CAAC;IACxB,KAAY,QAAQ,GAAG;QAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAA;IAE5F,UAAiB,gBAAgB;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;QAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAA;KACvC;IAEM,MAAM,MAAM,GAAU,QAAQ,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC;QAC7E,QAAQ,EAAE,cAAc,CAAC;QACzB,OAAO,EAAE,aAAa,CAAC;QACvB,SAAS,EAAE,gBAAgB,CAAA;KAC9B,CAyBA,CAAA;IAEM,MAAM,MAAM,GAAU,UAAU,eAAe,EACzB,eAAe,mBAAmB,EAClC,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAiB1E,CAAA;CACJ"}
+{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+C,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAEnF,OAAO,EAAsB,cAAc,EAAE,aAAa,EAAC,MAAM,yBAAyB,CAAA;AAC1F,OAAO,EAAC,eAAe,EAAE,mBAAmB,EAAC,MAAM,0BAA0B,CAAA;AAI7E,yBAAiB,UAAU,CAAC;IACxB,KAAY,QAAQ,GAAG;QAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAA;IAE5F,UAAiB,gBAAgB;QAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;QAChC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAA;KACvC;IAEM,MAAM,MAAM,GAAU,QAAQ,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC;QAC7E,QAAQ,EAAE,cAAc,CAAC;QACzB,OAAO,EAAE,aAAa,CAAC;QACvB,SAAS,EAAE,gBAAgB,CAAA;KAC9B,CAgCA,CAAA;IAEM,MAAM,MAAM,GAAU,UAAU,eAAe,EACzB,eAAe,mBAAmB,EAClC,UAAU,cAAc,KAAG,OAAO,CAAC,WAAW,CAwB1E,CAAA;CACJ"}

package/dist/dawproject/DawProject.js

@@ -1,4 +1,4 @@
-import { asDefined, isDefined, panic, UUID } from "@opendaw/lib-std";
+import { asDefined, isDefined, panic, RuntimeNotifier, UUID } from "@opendaw/lib-std";
 import { Xml } from "@opendaw/lib-xml";
 import { FileReferenceSchema, MetaDataSchema, ProjectSchema } from "@opendaw/lib-dawproject";
 import { DawProjectExporter } from "./DawProjectExporter";
@@ -6,7 +6,14 @@ import { ExternalLib } from "../ExternalLib";
 export var DawProject;
 (function (DawProject) {
     DawProject.decode = async (buffer) => {
-        const JSZip = await ExternalLib.JSZip();
+        const { status, value: JSZip, error } = await ExternalLib.JSZip();
+        if (status === "rejected") {
+            await RuntimeNotifier.info({
+                headline: "Error",
+                message: `Could not load JSZip: ${String(error)}`
+            });
+            return Promise.reject(error);
+        }
         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);
@@ -30,7 +37,14 @@ export var DawProject;
         };
     };
     DawProject.encode = async (skeleton, sampleManager, metaData) => {
-        const JSZip = await ExternalLib.JSZip();
+        const { status, value: JSZip, error } = await ExternalLib.JSZip();
+        if (status === "rejected") {
+            await RuntimeNotifier.info({
+                headline: "Error",
+                message: `Could not load JSZip: ${String(error)}`
+            });
+            return Promise.reject(error);
+        }
         const zip = new JSZip();
         const projectSchema = DawProjectExporter.write(skeleton, sampleManager, {
             write: (path, buffer) => {

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

@@ -1 +1 @@
-{"version":3,"file":"DawProjectImporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectImporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAiBH,IAAI,EAEP,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAcH,aAAa,EAOhB,MAAM,yBAAyB,CAAA;AAyBhC,OAAO,EAOH,eAAe,EAElB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAKvC,yBAAiB,gBAAgB,CAAC;IAW9B,KAAY,MAAM,GAAG;QACjB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpC,QAAQ,EAAE,eAAe,CAAA;KAC5B,CAAA;IAOM,MAAM,IAAI,GAAU,QAAQ,aAAa,EAAE,WAAW,UAAU,CAAC,gBAAgB,KAAG,OAAO,CAAC,MAAM,CAqYxG,CAAA;CAaJ"}
+{"version":3,"file":"DawProjectImporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectImporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAiBH,IAAI,EAEP,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAcH,aAAa,EAOhB,MAAM,yBAAyB,CAAA;AAyBhC,OAAO,EAMH,eAAe,EAElB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAIvC,yBAAiB,gBAAgB,CAAC;IAW9B,KAAY,MAAM,GAAG;QACjB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpC,QAAQ,EAAE,eAAe,CAAA;KAC5B,CAAA;IAOM,MAAM,IAAI,GAAU,QAAQ,aAAa,EAAE,WAAW,UAAU,CAAC,gBAAgB,KAAG,OAAO,CAAC,MAAM,CAyYxG,CAAA;CAaJ"}

package/dist/dawproject/DawProjectImporter.js

@@ -4,8 +4,7 @@ import { gainToDb, PPQN } from "@opendaw/lib-dsp";
 import { ChannelRole, ClipsSchema, DeviceRole, EqualizerSchema, LanesSchema, NotesSchema, PointsSchema, SendType, TrackSchema, WarpsSchema } from "@opendaw/lib-dawproject";
 import { AudioSendRouting, AudioUnitType, IconSymbol } from "@opendaw/studio-enums";
 import { AudioBusBox, AudioFileBox, AudioPitchStretchBox, AudioRegionBox, AudioUnitBox, AuxSendBox, BoxIO, CaptureAudioBox, CaptureMidiBox, GrooveShuffleBox, NoteEventBox, NoteEventCollectionBox, NoteRegionBox, RootBox, TimelineBox, TrackBox, UnknownAudioEffectDeviceBox, UnknownMidiEffectDeviceBox, UserInterfaceBox, ValueEventCollectionBox } from "@opendaw/studio-boxes";
-import { AudioUnitOrdering, ColorCodes, DeviceBoxUtils, InstrumentFactories, TrackType } from "@opendaw/studio-adapters";
-import { DeviceIO } from "./DeviceIO";
+import { AudioUnitOrdering, ColorCodes, InstrumentFactories, TrackType } from "@opendaw/studio-adapters";
 import { BuiltinDevices } from "./BuiltinDevices";
 import { AudioContentHelpers } from "../project/audio/AudioContentHelpers";
 export var DawProjectImport;
@@ -61,17 +60,19 @@ export var DawProjectImport;
         const createEffect = (device, field, index) => {
             const { deviceRole, deviceVendor, deviceID, deviceName, state } = device;
             assert(deviceRole === DeviceRole.NOTE_FX || deviceRole === DeviceRole.AUDIO_FX, "Device is not an effect");
-            if (deviceVendor === "openDAW") {
-                console.debug(`Recreate openDAW effect device '${deviceName}' with id '${deviceID}'`);
-                const resource = ifDefined(state?.path, path => resources.fromPath(path));
+            /*
+             TODO There is a bug in this if branch, which results in an invalid host pointer
+             if (deviceVendor === "openDAW") {
+                console.debug(`Recreate openDAW effect device '${deviceName}' with id '${deviceID}'`)
+                const resource = ifDefined(state?.path, path => resources.fromPath(path))
                 if (isDefined(resource)) {
-                    const device = DeviceIO.importDevice(boxGraph, resource.buffer);
-                    device.host.refer(field);
-                    device.label.setValue(deviceName ?? "");
-                    DeviceBoxUtils.lookupIndexField(device).setValue(index);
-                    return;
+                    const device = DeviceIO.importDevice(boxGraph, resource.buffer)
+                    device.host.refer(field)
+                    device.label.setValue(deviceName ?? "")
+                    DeviceBoxUtils.lookupIndexField(device).setValue(index)
+                    return
                 }
-            }
+            }*/
             if (isInstanceOf(device, EqualizerSchema)) {
                 return BuiltinDevices.equalizer(boxGraph, device, field, index);
             }
@@ -112,20 +113,22 @@ export var DawProjectImport;
             });
         };
         const createInstrumentBox = (audioUnitBox, track, device) => {
+            /*
+            TODO There is a bug in this if branch, which results in an invalid host pointer
             if (isDefined(device)) {
-                const { deviceName, deviceVendor, deviceID, state } = device;
+                const {deviceName, deviceVendor, deviceID, state} = device
                 if (deviceVendor === "openDAW") {
-                    console.debug(`Recreate openDAW instrument device '${deviceName}' with id '${deviceID}'`);
-                    const resource = ifDefined(state?.path, path => resources.fromPath(path));
+                    console.debug(`Recreate openDAW instrument device '${deviceName}' with id '${deviceID}'`)
+                    const resource = ifDefined(state?.path, path => resources.fromPath(path))
                     if (isDefined(resource)) {
-                        const device = DeviceIO.importDevice(boxGraph, resource.buffer);
-                        device.host.refer(audioUnitBox.input);
-                        device.label.setValue(deviceName ?? "");
-                        assert(DeviceBoxUtils.isInstrumentDeviceBox(device), `${device.name} is not an instrument`);
-                        return device;
+                        const device = DeviceIO.importDevice(boxGraph, resource.buffer)
+                        device.host.refer(audioUnitBox.input)
+                        device.label.setValue(deviceName ?? "")
+                        assert(DeviceBoxUtils.isInstrumentDeviceBox(device), `${device.name} is not an instrument`)
+                        return device as InstrumentBox
                     }
                 }
-            }
+            }*/
             if (track.contentType === "notes") {
                 return InstrumentFactories.Vaporisateur
                     .create(boxGraph, audioUnitBox.input, track.name ?? "", IconSymbol.Piano);

package/dist/midi/MIDILearning.d.ts

@@ -1,26 +1,14 @@
-import { byte, JSONValue, Provider, Terminable } from "@opendaw/lib-std";
-import { Address, AddressJSON, PrimitiveField, PrimitiveValues } from "@opendaw/lib-box";
+import { Terminable } from "@opendaw/lib-std";
+import { Address, Field, PrimitiveField, PrimitiveValues } from "@opendaw/lib-box";
 import { Pointers } from "@opendaw/studio-enums";
 import { Project } from "../project";
-export type MIDIConnectionJSON = ({
-    type: "control";
-    controlId: byte;
-}) & {
-    address: AddressJSON;
-    channel: byte;
-} & JSONValue;
-export interface MIDIConnection extends Terminable {
-    address: Address;
-    label: Provider<string>;
-    toJSON(): MIDIConnectionJSON;
-}
 export declare class MIDILearning implements Terminable {
     #private;
     constructor(project: Project);
+    followUser(field: Field<Pointers.MIDIControllers>): void;
     hasMidiConnection(address: Address): boolean;
     forgetMidiConnection(address: Address): void;
-    learnMIDIControls(field: PrimitiveField<PrimitiveValues, Pointers.MidiControl | Pointers>): Promise<void>;
-    toJSON(): ReadonlyArray<MIDIConnectionJSON>;
+    learnMIDIControls(field: PrimitiveField<PrimitiveValues, Pointers.MIDIControl | Pointers>): Promise<void>;
     terminate(): void;
 }
 //# sourceMappingURL=MIDILearning.d.ts.map

package/dist/midi/MIDILearning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MIDILearning.d.ts","sourceRoot":"","sources":["../../src/midi/MIDILearning.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,IAAI,EAIJ,SAAS,EAGT,QAAQ,EAGR,UAAU,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAA;AAEtF,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAIlC,MAAM,MAAM,kBAAkB,GAAG,CAAC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,GACjE;IAAE,OAAO,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GACvC,SAAS,CAAA;AAEf,MAAM,WAAW,cAAe,SAAQ,UAAU;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IACvB,MAAM,IAAI,kBAAkB,CAAA;CAC/B;AAID,qBAAa,YAAa,YAAW,UAAU;;gBAM/B,OAAO,EAAE,OAAO;IAK5B,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAC5C,oBAAoB,CAAC,OAAO,EAAE,OAAO;IAE/B,iBAAiB,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,EAAE,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC;IAsB/F,MAAM,IAAI,aAAa,CAAC,kBAAkB,CAAC;IAI3C,SAAS,IAAI,IAAI;CAiEpB"}
+{"version":3,"file":"MIDILearning.d.ts","sourceRoot":"","sources":["../../src/midi/MIDILearning.ts"],"names":[],"mappings":"AAAA,OAAO,EAYH,UAAU,EAGb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAA;AAEhF,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAelC,qBAAa,YAAa,YAAW,UAAU;;gBAS/B,OAAO,EAAE,OAAO;IAK5B,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI;IAkBxD,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAI5C,oBAAoB,CAAC,OAAO,EAAE,OAAO;IAK/B,iBAAiB,CAAC,KAAK,EAAE,cAAc,CAAC,eAAe,EAAE,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC;IAuC/F,SAAS,IAAI,IAAI;CA8DpB"}

package/dist/midi/MIDILearning.js

@@ -1,107 +1,140 @@
-import { Errors, isDefined, isNotNull, RuntimeNotifier, Terminator } from "@opendaw/lib-std";
+import { asDefined, asInstanceOf, EmptyExec, Errors, isNotNull, Option, RuntimeNotifier, Terminator, UUID } from "@opendaw/lib-std";
 import { Address } from "@opendaw/lib-box";
 import { MidiData } from "@opendaw/lib-midi";
 import { MidiDevices } from "./MidiDevices";
 import { AnimationFrame } from "@opendaw/lib-dom";
+import { MIDIControllerBox } from "@opendaw/studio-boxes";
+// will be part of MIDI preferences. Should not filter for the device-id
+// because it is different for the same hardware in different browsers.
+const respectDeviceID = false;
 export class MIDILearning {
     #terminator = new Terminator();
     #project;
     #connections;
+    #optMIDIContollers = Option.None;
+    #optFieldSubscription = Option.None;
     constructor(project) {
         this.#project = project;
-        this.#connections = Address.newSet(connection => connection.address);
+        this.#connections = Address.newSet(connection => connection.box.address);
+    }
+    followUser(field) {
+        this.#killAllConnections();
+        this.#optFieldSubscription.ifSome(subscription => subscription.terminate());
+        this.#optFieldSubscription = Option.None;
+        this.#optMIDIContollers = Option.wrap(field);
+        this.#optFieldSubscription = Option.wrap(field.pointerHub.catchupAndSubscribe({
+            onAdded: ({ box: anyBox }) => {
+                if (MidiDevices.get().isEmpty() && MidiDevices.canRequestMidiAccess()) {
+                    MidiDevices.requestPermission().then(EmptyExec, EmptyExec);
+                }
+                const box = asInstanceOf(anyBox, MIDIControllerBox);
+                const { subscription, handleEvent } = this.#registerMIDIControllerBox(box);
+                this.#connections.add({ box, subscription, handleEvent });
+            },
+            onRemoved: ({ box: { address } }) => this.#connections.removeByKey(address).subscription.terminate()
+        }));
+    }
+    hasMidiConnection(address) {
+        return this.#findConnectionByParameterAddress(address).nonEmpty();
+    }
+    forgetMidiConnection(address) {
+        const connection = this.#findConnectionByParameterAddress(address).unwrap("No connection to forget");
+        this.#project.editing.modify(() => asDefined(connection).box.delete());
     }
-    hasMidiConnection(address) { return this.#connections.hasKey(address); }
-    forgetMidiConnection(address) { this.#connections.removeByKey(address).terminate(); }
     async learnMIDIControls(field) {
+        if (this.#optMIDIContollers.isEmpty()) {
+            return RuntimeNotifier.info({
+                headline: "Learn Midi Controller...",
+                message: "No user accepting midi controls."
+            });
+        }
         if (!MidiDevices.canRequestMidiAccess()) {
             return;
         }
         await MidiDevices.requestPermission();
         const learnLifecycle = this.#terminator.spawn();
         const abortController = new AbortController();
+        // TODO subscribeMessageEvents is not really suffient, because it does not distinguish between midi devices.
         learnLifecycle.own(MidiDevices.subscribeMessageEvents((event) => {
             const data = event.data;
             if (data === null) {
                 return;
             }
+            const deviceId = event.target instanceof MIDIInput ? event.target.id : "";
             if (MidiData.isController(data)) {
                 learnLifecycle.terminate();
                 abortController.abort(Errors.AbortError);
-                return this.#startListeningControl(field, MidiData.readChannel(data), MidiData.readParam1(data), event);
+                const midiControllersField = this.#optMIDIContollers.unwrap();
+                const { editing } = this.#project;
+                const optBox = editing.modify(() => MIDIControllerBox.create(this.#project.boxGraph, UUID.generate(), box => {
+                    box.controllers.refer(midiControllersField);
+                    box.parameter.refer(field);
+                    box.deviceId.setValue(deviceId);
+                    box.deviceChannel.setValue(MidiData.readChannel(data));
+                    box.controlId.setValue(MidiData.readParam1(data));
+                }));
+                this.#connections.get(optBox.unwrap("Could not create MIDIControllerBox").address).handleEvent(event);
             }
         }));
         return RuntimeNotifier.info({
-            headline: "Learn Midi Keys...",
-            message: "Hit a key on your midi-device to learn a connection.",
+            headline: "Learn Midi Controller...",
+            message: "Turn a controller on your midi-device...",
             okText: "Cancel",
             abortSignal: abortController.signal
         }).then(() => learnLifecycle.terminate(), Errors.CatchAbort);
     }
-    toJSON() {
-        return this.#connections.values().map(connection => connection.toJSON());
-    }
     terminate() {
         this.#killAllConnections();
         this.#terminator.terminate();
     }
-    #startListeningControl(field, channel, controlId, event) {
-        console.debug(`startListeningControl channel: ${channel}, controlId: ${controlId}`);
-        const { observer, terminate } = this.#createMidiControlObserver(this.#project, this.#project.parameterFieldAdapters.get(field.address), controlId);
-        if (isDefined(event)) {
-            observer(event);
-        }
-        const subscription = MidiDevices.subscribeMessageEvents(observer, channel);
-        this.#connections.add({
-            address: field.address,
-            toJSON: () => ({
-                type: "control",
-                address: field.address.toJSON(),
-                channel,
-                controlId
-            }),
-            label: () => this.#project.parameterFieldAdapters.get(field.address).name,
-            terminate: () => {
-                terminate();
-                subscription.terminate();
-            }
-        });
-    }
-    #killAllConnections() {
-        this.#connections.forEach(({ terminate }) => terminate());
-        this.#connections.clear();
-    }
-    #createMidiControlObserver(project, adapter, controlId) {
+    #registerMIDIControllerBox({ parameter: { targetAddress }, controlId, deviceId, deviceChannel }) {
+        const address = targetAddress.unwrap("No parameter address");
+        const adapter = this.#project.parameterFieldAdapters.get(address);
+        const { editing } = this.#project;
         const registration = adapter.registerMidiControl();
         let pendingValue = null;
-        const update = (value) => project.editing.modify(() => adapter.setValue(adapter.valueMapping.y(value)), false);
-        return {
-            observer: (event) => {
-                const data = event.data;
-                if (data === null) {
-                    return;
+        const update = (value) => editing.modify(() => adapter.setUnitValue(value), false);
+        const handleEvent = (event) => {
+            const data = event.data;
+            if (data === null) {
+                return;
+            }
+            const id = event.target instanceof MIDIInput ? event.target.id : "";
+            if (MidiData.isController(data)
+                && MidiData.readParam1(data) === controlId.getValue() && (!respectDeviceID || id === deviceId.getValue())) {
+                const value = MidiData.asValue(data);
+                if (pendingValue === null) {
+                    update(value);
+                    pendingValue = value;
+                    AnimationFrame.once(() => {
+                        if (isNotNull(pendingValue)) {
+                            update(pendingValue);
+                            pendingValue = null;
+                        }
+                    });
                 }
-                if (MidiData.isController(data) && MidiData.readParam1(data) === controlId) {
-                    const value = MidiData.asValue(data);
-                    if (pendingValue === null) {
-                        update(value);
-                        pendingValue = value;
-                        AnimationFrame.once(() => {
-                            if (isNotNull(pendingValue)) {
-                                update(pendingValue);
-                                pendingValue = null;
-                            }
-                        });
-                    }
-                    else {
-                        pendingValue = value;
-                    }
+                else {
+                    pendingValue = value;
                 }
-            },
-            terminate: () => {
-                pendingValue = null;
-                registration.terminate();
             }
         };
+        const channel = deviceChannel.getValue() === -1 ? undefined : deviceChannel.getValue();
+        const subscription = MidiDevices.subscribeMessageEvents(handleEvent, channel);
+        return {
+            subscription: {
+                terminate: () => {
+                    pendingValue = null;
+                    subscription.terminate();
+                    registration.terminate();
+                }
+            }, handleEvent
+        };
+    }
+    #killAllConnections() {
+        this.#connections.forEach(({ subscription }) => subscription.terminate());
+        this.#connections.clear();
+    }
+    #findConnectionByParameterAddress(address) {
+        return Option.wrap(this.#connections.values().find(({ box }) => box.parameter.targetAddress.unwrap() === address));
     }
 }