@opendaw/studio-adapters 0.0.6

package/dist/audio-unit/AudioUnitBoxAdapter.js

@@ -0,0 +1,97 @@
+import { StringMapping, Terminator, ValueMapping } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { Devices } from "../devices";
+import { AudioUnitTracks } from "./AudioUnitTracks";
+import { AudioUnitInput } from "./AudioUnitInput";
+import { SortedBoxAdapterCollection } from "../SortedBoxAdapterCollection";
+import { ParameterAdapterSet } from "../ParameterAdapterSet";
+import { AuxSendBoxAdapter } from "./AuxSendBoxAdapter";
+import { AudioUnitOutput } from "./AudioUnitOutput";
+export class AudioUnitBoxAdapter {
+    "class" = "device-host";
+    #terminator = new Terminator();
+    #context;
+    #box;
+    #parametric;
+    #tracks;
+    #input;
+    #midiEffects;
+    #audioEffects;
+    #auxSends;
+    #output;
+    namedParameter; // let typescript infer the type
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#parametric = this.#terminator.own(new ParameterAdapterSet(this.#context));
+        this.#tracks = this.#terminator.own(new AudioUnitTracks(this, this.#context.boxAdapters));
+        this.#input = this.#terminator.own(new AudioUnitInput(this.#box.input.pointerHub, this.#context.boxAdapters));
+        this.#midiEffects = this.#terminator.own(SortedBoxAdapterCollection.create(this.#box.midiEffects, box => this.#context.boxAdapters.adapterFor(box, Devices.isMidiEffect), Pointers.MidiEffectHost));
+        this.#audioEffects = this.#terminator.own(SortedBoxAdapterCollection.create(this.#box.audioEffects, box => this.#context.boxAdapters.adapterFor(box, Devices.isAudioEffect), Pointers.AudioEffectHost));
+        this.#auxSends = this.#terminator.own(SortedBoxAdapterCollection.create(this.#box.auxSends, box => this.#context.boxAdapters.adapterFor(box, AuxSendBoxAdapter), Pointers.AuxSend));
+        this.#output = this.#terminator.own(new AudioUnitOutput(this.#box.output, this.#context.boxAdapters));
+        this.namedParameter = this.#wrapParameters(box);
+    }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get indexField() { return this.#box.index; }
+    get type() { return this.#box.type.getValue(); }
+    get tracks() { return this.#tracks; }
+    get input() { return this.#input; }
+    get midiEffects() { return this.#midiEffects; }
+    get audioEffects() { return this.#audioEffects; }
+    get inputAdapter() { return this.#input.getValue(); }
+    get auxSends() { return this.#auxSends; }
+    get output() { return this.#output; }
+    get isBus() { return this.input.getValue().mapOr(adapter => adapter.type === "bus", false); }
+    get isInstrument() { return this.input.getValue().mapOr(adapter => adapter.type === "instrument", false); }
+    get isOutput() {
+        return this.#box.output.targetVertex.mapOr(output => output.box.address.equals(this.#context.rootBoxAdapter.address), false);
+    }
+    get midiEffectsField() { return this.#box.midiEffects; }
+    get inputField() { return this.#box.input; }
+    get audioEffectsField() { return this.#box.audioEffects; }
+    get tracksField() { return this.#box.tracks; }
+    get minimizedField() { return this.#input.getValue().unwrap().minimizedField; }
+    get isAudioUnit() { return true; }
+    get label() { return this.#input.getValue().mapOr(input => input.labelField.getValue(), ""); }
+    audioUnitBoxAdapter() { return this; }
+    indicesLimit() {
+        const adapters = this.#context.rootBoxAdapter.audioUnits.adapters();
+        const startIndex = this.indexField.getValue();
+        const unitType = this.type;
+        let min = startIndex;
+        let max = startIndex;
+        while (min > 0) {
+            if (adapters[min - 1].type === unitType) {
+                min--;
+            }
+            else {
+                break;
+            }
+        }
+        while (max < adapters.length - 1) {
+            if (adapters[max + 1].type === unitType) {
+                max++;
+            }
+            else {
+                break;
+            }
+        }
+        return [min, max + 1];
+    }
+    move(delta) { this.#context.rootBoxAdapter.audioUnits.move(this, delta); }
+    moveTrack(adapter, delta) { this.#tracks.collection.move(adapter, delta); }
+    deleteTrack(adapter) { this.#tracks.delete(adapter); }
+    toString() { return `{${this.constructor.name}}`; }
+    terminate() { this.#terminator.terminate(); }
+    #wrapParameters(box) {
+        return {
+            volume: this.#parametric.createParameter(box.volume, ValueMapping.decibel(-96.0, -9.0, +6.0), StringMapping.decible, "volume"),
+            panning: this.#parametric.createParameter(box.panning, ValueMapping.bipolar(), StringMapping.panning, "panning", 0.5),
+            mute: this.#parametric.createParameter(box.mute, ValueMapping.bool, StringMapping.bool, "mute"),
+            solo: this.#parametric.createParameter(box.solo, ValueMapping.bool, StringMapping.bool, "solo")
+        };
+    }
+}

package/dist/audio-unit/AudioUnitInput.d.ts

@@ -0,0 +1,21 @@
+import { DefaultObservableValue, ObservableValue, Observer, Option, Terminable } from "@opendaw/lib-std";
+import { PointerHub } from "@opendaw/lib-box";
+import { IconSymbol } from "../IconSymbol";
+import { AudioUnitInputAdapter } from "./AudioUnitInputAdapter";
+import { BoxAdapters } from "../BoxAdapters";
+export declare class AudioUnitInput implements ObservableValue<Option<AudioUnitInputAdapter>>, Terminable {
+    #private;
+    constructor(pointerHub: PointerHub, boxAdapters: BoxAdapters);
+    getValue(): Option<AudioUnitInputAdapter>;
+    subscribe(observer: Observer<ObservableValue<Option<AudioUnitInputAdapter>>>): Terminable;
+    catchupAndSubscribe(observer: Observer<ObservableValue<Option<AudioUnitInputAdapter>>>): Terminable;
+    catchupAndSubscribeLabelChange(observer: Observer<Option<string>>): Terminable;
+    catchupAndSubscribeIconChange(observer: Observer<ObservableValue<IconSymbol>>): Terminable;
+    set label(value: string);
+    get label(): Option<string>;
+    set icon(value: IconSymbol);
+    get icon(): IconSymbol;
+    get iconValue(): DefaultObservableValue<IconSymbol>;
+    terminate(): void;
+}
+//# sourceMappingURL=AudioUnitInput.d.ts.map

package/dist/audio-unit/AudioUnitInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitInput.d.ts","sourceRoot":"","sources":["../../src/audio-unit/AudioUnitInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,sBAAsB,EAEtB,eAAe,EACf,QAAQ,EACR,MAAM,EAEN,UAAU,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAG3C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AACxC,OAAO,EAAC,qBAAqB,EAAC,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAI1C,qBAAa,cAAe,YAAW,eAAe,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,EAAE,UAAU;;gBAQjF,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW;IAoC5D,QAAQ,IAAI,MAAM,CAAC,qBAAqB,CAAC;IAEzC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC,GAAG,UAAU;IAIzF,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC,GAAG,UAAU;IAKnG,8BAA8B,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU;IAK9E,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,GAAG,UAAU;IAI1F,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,EAAqE;IAC5F,IAAI,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,CAAmE;IAE9F,IAAI,IAAI,CAAC,KAAK,EAAE,UAAU,EAAuF;IACjH,IAAI,IAAI,IAAI,UAAU,CAKrB;IAED,IAAI,SAAS,IAAI,sBAAsB,CAAC,UAAU,CAAC,CAAyB;IAE5E,SAAS,IAAI,IAAI;CAIpB"}

package/dist/audio-unit/AudioUnitInput.js

@@ -0,0 +1,74 @@
+import { assert, DefaultObservableValue, Notifier, Option, Terminable, Terminator } from "@opendaw/lib-std";
+import { AudioBusBox } from "@opendaw/studio-boxes";
+import { Pointers } from "@opendaw/studio-enums";
+import { IconSymbol } from "../IconSymbol";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+import { Devices } from "../devices";
+export class AudioUnitInput {
+    #terminator;
+    #labelNotifier;
+    #iconValue;
+    #observable;
+    #subscription = Terminable.Empty;
+    constructor(pointerHub, boxAdapters) {
+        this.#terminator = new Terminator();
+        this.#labelNotifier = this.#terminator.own(new Notifier());
+        this.#iconValue = this.#terminator.own(new DefaultObservableValue(IconSymbol.Unknown));
+        this.#observable = this.#terminator.own(new DefaultObservableValue(Option.None));
+        this.#terminator.own(this.#observable.subscribe(owner => {
+            this.#subscription.terminate();
+            this.#subscription = owner.getValue().match({
+                none: () => {
+                    this.#labelNotifier.notify(Option.None);
+                    return Terminable.Empty;
+                },
+                some: ({ labelField, iconField }) => Terminable.many(iconField.catchupAndSubscribe(field => this.#iconValue.setValue(IconSymbol.fromName(field.getValue()))), labelField.catchupAndSubscribe(field => this.#labelNotifier.notify(Option.wrap(field.getValue()))))
+            });
+        }));
+        this.#terminator.own(pointerHub.catchupAndSubscribeTransactual({
+            onAdd: ({ box }) => {
+                assert(this.#observable.getValue().isEmpty(), "Already set");
+                const input = box instanceof AudioBusBox
+                    ? boxAdapters.adapterFor(box, AudioBusBoxAdapter)
+                    : boxAdapters.adapterFor(box, Devices.isInstrument);
+                if (this.#observable.getValue().unwrapOrNull() !== input) {
+                    this.#observable.setValue(Option.wrap(input));
+                }
+            },
+            onRemove: ({ box }) => {
+                assert(this.#observable.getValue().unwrap("Cannot remove").box.address
+                    .equals(box.address), "Unexpected value to remove");
+                this.#observable.setValue(Option.None);
+            }
+        }, Pointers.InstrumentHost, Pointers.AudioOutput));
+    }
+    getValue() { return this.#observable.getValue(); }
+    subscribe(observer) {
+        return this.#observable.subscribe(observer);
+    }
+    catchupAndSubscribe(observer) {
+        observer(this.#observable);
+        return this.subscribe(observer);
+    }
+    catchupAndSubscribeLabelChange(observer) {
+        observer(this.label);
+        return this.#labelNotifier.subscribe(observer);
+    }
+    catchupAndSubscribeIconChange(observer) {
+        return this.#iconValue.catchupAndSubscribe(observer);
+    }
+    set label(value) { this.getValue().ifSome(input => input.labelField.setValue(value)); }
+    get label() { return this.getValue().map(input => input.labelField.getValue()); }
+    set icon(value) { this.getValue().ifSome(input => input.iconField.setValue(IconSymbol.toName(value))); }
+    get icon() {
+        return this.getValue().match({
+            none: () => IconSymbol.Unknown,
+            some: input => IconSymbol.fromName(input.iconField.getValue())
+        });
+    }
+    get iconValue() { return this.#iconValue; }
+    terminate() {
+        this.#terminator.terminate();
+        this.#subscription.terminate();
+    }
+}

package/dist/audio-unit/AudioUnitInputAdapter.d.ts

@@ -0,0 +1,4 @@
+import { InstrumentDeviceBoxAdapter } from "../devices";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+export type AudioUnitInputAdapter = InstrumentDeviceBoxAdapter | AudioBusBoxAdapter;
+//# sourceMappingURL=AudioUnitInputAdapter.d.ts.map

package/dist/audio-unit/AudioUnitInputAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitInputAdapter.d.ts","sourceRoot":"","sources":["../../src/audio-unit/AudioUnitInputAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,0BAA0B,EAAC,MAAM,YAAY,CAAA;AACrD,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AAEvD,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,GAAG,kBAAkB,CAAA"}

package/dist/audio-unit/AudioUnitInputAdapter.js

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

package/dist/audio-unit/AudioUnitOutput.d.ts

@@ -0,0 +1,14 @@
+import { Observer, Option, Subscription, Terminable } from "@opendaw/lib-std";
+import { PointerField } from "@opendaw/lib-box";
+import { Pointers } from "@opendaw/studio-enums";
+import { BoxAdapters } from "../BoxAdapters";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+export declare class AudioUnitOutput implements Terminable {
+    #private;
+    constructor(pointerField: PointerField<Pointers.AudioOutput>, boxAdapters: BoxAdapters);
+    subscribe(observer: Observer<Option<AudioBusBoxAdapter>>): Subscription;
+    catchupAndSubscribe(observer: Observer<Option<AudioBusBoxAdapter>>): Subscription;
+    get adapter(): Option<AudioBusBoxAdapter>;
+    terminate(): void;
+}
+//# sourceMappingURL=AudioUnitOutput.d.ts.map

package/dist/audio-unit/AudioUnitOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitOutput.d.ts","sourceRoot":"","sources":["../../src/audio-unit/AudioUnitOutput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAA;AACjG,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AAEvD,qBAAa,eAAgB,YAAW,UAAU;;gBASlC,YAAY,EAAE,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,EAAE,WAAW;IAmBtF,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,GAAG,YAAY;IAIvE,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,GAAG,YAAY;IAKjF,IAAI,OAAO,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAKxC;IAED,SAAS,IAAI,IAAI;CAIpB"}

package/dist/audio-unit/AudioUnitOutput.js

@@ -0,0 +1,42 @@
+import { Notifier, Option, Terminable, Terminator } from "@opendaw/lib-std";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+export class AudioUnitOutput {
+    #pointerField;
+    #boxAdapters;
+    #terminator;
+    #busChangeNotifier;
+    #subscription = Terminable.Empty;
+    constructor(pointerField, boxAdapters) {
+        this.#pointerField = pointerField;
+        this.#boxAdapters = boxAdapters;
+        this.#terminator = new Terminator();
+        this.#busChangeNotifier = this.#terminator.own(new Notifier());
+        this.#terminator.own(pointerField.catchupAndSubscribe(() => {
+            this.#subscription.terminate();
+            this.#subscription = this.adapter.match({
+                none: () => {
+                    this.#busChangeNotifier.notify(Option.None);
+                    return Terminable.Empty;
+                },
+                some: adapter => adapter.catchupAndSubscribe(adapter => this.#busChangeNotifier.notify(Option.wrap(adapter)))
+            });
+        }));
+    }
+    subscribe(observer) {
+        return this.#busChangeNotifier.subscribe(observer);
+    }
+    catchupAndSubscribe(observer) {
+        observer(this.adapter);
+        return this.subscribe(observer);
+    }
+    get adapter() {
+        return this.#pointerField.targetVertex
+            .flatMap(target => Option.wrap(target.box.accept({
+            visitAudioBusBox: (box) => this.#boxAdapters.adapterFor(box, AudioBusBoxAdapter)
+        })));
+    }
+    terminate() {
+        this.#terminator.terminate();
+        this.#subscription.terminate();
+    }
+}

package/dist/audio-unit/AudioUnitTracks.d.ts

@@ -0,0 +1,21 @@
+import { int, Observer, Option, Subscription, Terminable } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { Vertex } from "@opendaw/lib-box";
+import { AudioUnitBoxAdapter } from "./AudioUnitBoxAdapter";
+import { IndexedAdapterCollectionListener, SortedBoxAdapterCollection } from "../SortedBoxAdapterCollection";
+import { TrackBoxAdapter } from "../timeline/TrackBoxAdapter";
+import { BoxAdapters } from "../BoxAdapters";
+import { TrackType } from "../timeline/TrackType";
+export declare class AudioUnitTracks implements Terminable {
+    #private;
+    constructor(adapter: AudioUnitBoxAdapter, boxAdapters: BoxAdapters);
+    create(type: TrackType, target: Vertex<Pointers.Automation | Pointers>, index?: int): void;
+    controls(target: Vertex<Pointers.Automation | Pointers>): Option<TrackBoxAdapter>;
+    delete(adapter: TrackBoxAdapter): void;
+    get collection(): SortedBoxAdapterCollection<TrackBoxAdapter, Pointers.TrackCollection>;
+    values(): ReadonlyArray<TrackBoxAdapter>;
+    catchupAndSubscribe(listener: IndexedAdapterCollectionListener<TrackBoxAdapter>): Subscription;
+    subscribeAnyChange(observer: Observer<void>): Subscription;
+    terminate(): void;
+}
+//# sourceMappingURL=AudioUnitTracks.d.ts.map

package/dist/audio-unit/AudioUnitTracks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioUnitTracks.d.ts","sourceRoot":"","sources":["../../src/audio-unit/AudioUnitTracks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAY,QAAQ,EAAE,MAAM,EAAoB,YAAY,EAAE,UAAU,EAAO,MAAM,kBAAkB,CAAA;AAClH,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAA;AACzD,OAAO,EAAC,gCAAgC,EAAE,0BAA0B,EAAC,MAAM,+BAA+B,CAAA;AAC1G,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAA;AAE/C,qBAAa,eAAgB,YAAW,UAAU;;gBAQlC,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW;IAelE,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,GAAG,IAAI;IAW1F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC;IAKjF,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAUtC,IAAI,UAAU,IAAI,0BAA0B,CAAC,eAAe,EAAE,QAAQ,CAAC,eAAe,CAAC,CAA0B;IAEjH,MAAM,IAAI,aAAa,CAAC,eAAe,CAAC;IAExC,mBAAmB,CAAC,QAAQ,EAAE,gCAAgC,CAAC,eAAe,CAAC,GAAG,YAAY;IAI9F,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,YAAY;IAE1D,SAAS,IAAI,IAAI;CAMpB"}

package/dist/audio-unit/AudioUnitTracks.js

@@ -0,0 +1,62 @@
+import { Notifier, Option, panic, UUID } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { TrackBox } from "@opendaw/studio-boxes";
+import { SortedBoxAdapterCollection } from "../SortedBoxAdapterCollection";
+import { TrackBoxAdapter } from "../timeline/TrackBoxAdapter";
+export class AudioUnitTracks {
+    #adapter;
+    #regionNotifier = new Notifier();
+    #collection;
+    #subscriptions;
+    #subscription;
+    constructor(adapter, boxAdapters) {
+        this.#adapter = adapter;
+        this.#collection = SortedBoxAdapterCollection.create(adapter.box.tracks, box => boxAdapters.adapterFor(box, TrackBoxAdapter), Pointers.TrackCollection);
+        this.#subscriptions = UUID.newSet(({ uuid }) => uuid);
+        this.#subscription = this.#collection.catchupAndSubscribe({
+            onAdd: (adapter) => this.#subscriptions.add({
+                uuid: adapter.uuid,
+                subscription: adapter.regions.subscribeChanges(() => this.#regionNotifier.notify())
+            }),
+            onRemove: ({ uuid }) => this.#subscriptions.removeByKey(uuid).subscription.terminate(),
+            onReorder: (_adapter) => { }
+        });
+    }
+    create(type, target, index) {
+        const graph = this.#adapter.box.graph;
+        const tracks = this.#adapter.box.tracks;
+        TrackBox.create(graph, UUID.generate(), box => {
+            box.index.setValue(index ?? this.#collection.getMinFreeIndex());
+            box.type.setValue(type);
+            box.tracks.refer(tracks);
+            box.target.refer(target);
+        });
+    }
+    controls(target) {
+        return Option.wrap(this.#collection.adapters()
+            .find(adapter => adapter.target.targetVertex.contains(target), false));
+    }
+    delete(adapter) {
+        const adapters = this.#collection.adapters();
+        const deleteIndex = adapters.indexOf(adapter);
+        if (deleteIndex === -1) {
+            return panic(`Cannot delete ${adapter}. Does not exist.`);
+        }
+        for (let index = deleteIndex + 1; index < adapters.length; index++) {
+            adapters[index].indexField.setValue(index - 1);
+        }
+        adapter.box.delete();
+    }
+    get collection() { return this.#collection; }
+    values() { return this.#collection.adapters(); }
+    catchupAndSubscribe(listener) {
+        return this.#collection.catchupAndSubscribe(listener);
+    }
+    subscribeAnyChange(observer) { return this.#regionNotifier.subscribe(observer); }
+    terminate() {
+        this.#collection.terminate();
+        this.#subscription.terminate();
+        this.#subscriptions.forEach(({ subscription }) => subscription.terminate());
+        this.#subscriptions.clear();
+    }
+}

package/dist/audio-unit/AuxSendBoxAdapter.d.ts

@@ -0,0 +1,23 @@
+import { Address, Box, Int32Field } from "@opendaw/lib-box";
+import { float, Observer, Option, Subscription, UUID } from "@opendaw/lib-std";
+import { AuxSendBox } from "@opendaw/studio-boxes";
+import { BoxAdapter } from "../BoxAdapter";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+import { BoxAdaptersContext } from "../BoxAdaptersContext";
+import { AutomatableParameterFieldAdapter } from "../AutomatableParameterFieldAdapter";
+export declare class AuxSendBoxAdapter implements BoxAdapter {
+    #private;
+    constructor(context: BoxAdaptersContext, box: AuxSendBox);
+    catchupAndSubscribeBusChanges(observer: Observer<Option<AudioBusBoxAdapter>>): Subscription;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get box(): Box;
+    get indexField(): Int32Field;
+    get sendPan(): AutomatableParameterFieldAdapter<float>;
+    get sendGain(): AutomatableParameterFieldAdapter<float>;
+    get targetBus(): AudioBusBoxAdapter;
+    get optTargetBus(): Option<AudioBusBoxAdapter>;
+    delete(): void;
+    terminate(): void;
+}
+//# sourceMappingURL=AuxSendBoxAdapter.d.ts.map

package/dist/audio-unit/AuxSendBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuxSendBoxAdapter.d.ts","sourceRoot":"","sources":["../../src/audio-unit/AuxSendBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,GAAG,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AACzD,OAAO,EACH,KAAK,EAEL,QAAQ,EACR,MAAM,EAEN,YAAY,EAGZ,IAAI,EAEP,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAc,UAAU,EAAa,MAAM,uBAAuB,CAAA;AACzE,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AACxC,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAC,gCAAgC,EAAC,MAAM,qCAAqC,CAAA;AAEpF,qBAAa,iBAAkB,YAAW,UAAU;;gBAYpC,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,UAAU;IA6BxD,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,GAAG,YAAY;IAK3F,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,GAAG,IAAI,GAAG,CAAmB;IACjC,IAAI,UAAU,IAAI,UAAU,CAAyB;IACrD,IAAI,OAAO,IAAI,gCAAgC,CAAC,KAAK,CAAC,CAAuB;IAC7E,IAAI,QAAQ,IAAI,gCAAgC,CAAC,KAAK,CAAC,CAAwB;IAC/E,IAAI,SAAS,IAAI,kBAAkB,CAGlC;IAED,IAAI,YAAY,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAK7C;IAED,MAAM,IAAI,IAAI;IAEd,SAAS,IAAI,IAAI;CAIpB"}

package/dist/audio-unit/AuxSendBoxAdapter.js

@@ -0,0 +1,58 @@
+import { Notifier, Option, StringMapping, Terminable, Terminator, ValueMapping } from "@opendaw/lib-std";
+import { AudioBusBoxAdapter } from "./AudioBusBoxAdapter";
+import { AutomatableParameterFieldAdapter } from "../AutomatableParameterFieldAdapter";
+export class AuxSendBoxAdapter {
+    #context;
+    #box;
+    #terminator;
+    #busChangeNotifier;
+    #sendPan;
+    #sendGain;
+    #subscription = Terminable.Empty;
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#terminator = new Terminator();
+        this.#busChangeNotifier = this.#terminator.own(new Notifier());
+        this.#terminator.own(box.targetBus.catchupAndSubscribe(() => {
+            this.#subscription.terminate();
+            this.#subscription = this.optTargetBus.match({
+                none: () => {
+                    this.#busChangeNotifier.notify(Option.None);
+                    return Terminable.Empty;
+                },
+                some: adapter => adapter.catchupAndSubscribe(adapter => this.#busChangeNotifier.notify(Option.wrap(adapter)))
+            });
+        }));
+        this.#sendPan = this.#terminator.own(new AutomatableParameterFieldAdapter(this.#context, this.#box.sendPan, ValueMapping.bipolar(), StringMapping.percent({ unit: "%", fractionDigits: 0 }), "panning"));
+        this.#sendGain = this.#terminator.own(new AutomatableParameterFieldAdapter(this.#context, this.#box.sendGain, ValueMapping.DefaultDecibel, StringMapping.numeric({
+            unit: "dB",
+            fractionDigits: 1
+        }), "gain"));
+    }
+    catchupAndSubscribeBusChanges(observer) {
+        observer(this.optTargetBus);
+        return this.#busChangeNotifier.subscribe(observer);
+    }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get box() { return this.#box; }
+    get indexField() { return this.#box.index; }
+    get sendPan() { return this.#sendPan; }
+    get sendGain() { return this.#sendGain; }
+    get targetBus() {
+        return this.#context.boxAdapters
+            .adapterFor(this.#box.targetBus.targetVertex.unwrap("no audioUnit").box, AudioBusBoxAdapter);
+    }
+    get optTargetBus() {
+        return this.#box.targetBus.targetVertex
+            .flatMap(target => Option.wrap(target.box.accept({
+            visitAudioBusBox: (box) => this.#context.boxAdapters.adapterFor(box, AudioBusBoxAdapter)
+        })));
+    }
+    delete() { this.#box.delete(); }
+    terminate() {
+        this.#terminator.terminate();
+        this.#subscription.terminate();
+    }
+}

package/dist/devices/audio-effects/DelayDeviceBoxAdapter.d.ts

@@ -0,0 +1,35 @@
+import { DelayDeviceBox } from "@opendaw/studio-boxes";
+import { StringMapping, UUID } from "@opendaw/lib-std";
+import { Address, BooleanField, Int32Field, PointerField, StringField } from "@opendaw/lib-box";
+import { Pointers } from "@opendaw/studio-enums";
+import { AudioEffectDeviceBoxAdapter, DeviceHost } from "../../devices";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+import { AudioUnitBoxAdapter } from "../../audio-unit/AudioUnitBoxAdapter";
+export declare class DelayDeviceBoxAdapter implements AudioEffectDeviceBoxAdapter {
+    #private;
+    static OffsetFractions: readonly (readonly [number, number])[];
+    static OffsetStringMapping: StringMapping<number>;
+    readonly type = "audio-effect";
+    readonly accepts = "audio";
+    readonly namedParameter: {
+        readonly delay: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly feedback: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly cross: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly filter: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly dry: import("../..").AutomatableParameterFieldAdapter<number>;
+        readonly wet: import("../..").AutomatableParameterFieldAdapter<number>;
+    };
+    constructor(context: BoxAdaptersContext, box: DelayDeviceBox);
+    get box(): DelayDeviceBox;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get indexField(): Int32Field;
+    get labelField(): StringField;
+    get enabledField(): BooleanField;
+    get minimizedField(): BooleanField;
+    get host(): PointerField<Pointers.AudioEffectHost>;
+    deviceHost(): DeviceHost;
+    audioUnitBoxAdapter(): AudioUnitBoxAdapter;
+    terminate(): void;
+}
+//# sourceMappingURL=DelayDeviceBoxAdapter.d.ts.map

package/dist/devices/audio-effects/DelayDeviceBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DelayDeviceBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/devices/audio-effects/DelayDeviceBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAC,aAAa,EAAE,IAAI,EAAe,MAAM,kBAAkB,CAAA;AAClE,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAA;AAC7F,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAE9C,OAAO,EAAC,2BAA2B,EAAE,UAAU,EAAU,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAE3D,OAAO,EAAC,mBAAmB,EAAC,MAAM,sCAAsC,CAAA;AAExE,qBAAa,qBAAsB,YAAW,2BAA2B;;IACrE,MAAM,CAAC,eAAe,yCAME;IAExB,MAAM,CAAC,mBAAmB,wBAA+E;IAEzG,QAAQ,CAAC,IAAI,kBAAiB;IAC9B,QAAQ,CAAC,OAAO,WAAU;IAM1B,QAAQ,CAAC,cAAc;;;;;;;MAAA;gBAEX,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,cAAc;IAO5D,IAAI,GAAG,IAAI,cAAc,CAAmB;IAC5C,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,UAAU,IAAI,UAAU,CAAyB;IACrD,IAAI,UAAU,IAAI,WAAW,CAAyB;IACtD,IAAI,YAAY,IAAI,YAAY,CAA2B;IAC3D,IAAI,cAAc,IAAI,YAAY,CAA6B;IAC/D,IAAI,IAAI,IAAI,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAwB;IAE1E,UAAU,IAAI,UAAU;IAKxB,mBAAmB,IAAI,mBAAmB;IAE1C,SAAS,IAAI,IAAI;CA8BpB"}

package/dist/devices/audio-effects/DelayDeviceBoxAdapter.js

@@ -0,0 +1,50 @@
+import { StringMapping, ValueMapping } from "@opendaw/lib-std";
+import { Fraction } from "@opendaw/lib-dsp";
+import { Devices } from "../../devices";
+import { ParameterAdapterSet } from "../../ParameterAdapterSet";
+export class DelayDeviceBoxAdapter {
+    static OffsetFractions = Fraction.builder()
+        .add([1, 1]).add([1, 2]).add([1, 3]).add([1, 4])
+        .add([3, 16]).add([1, 6]).add([1, 8]).add([3, 32])
+        .add([1, 12]).add([1, 16]).add([3, 64]).add([1, 24])
+        .add([1, 32]).add([1, 48]).add([1, 64])
+        .add([1, 96]).add([1, 128])
+        .asDescendingArray();
+    static OffsetStringMapping = StringMapping.indices("", this.OffsetFractions.map(([n, d]) => `${n}/${d}`));
+    type = "audio-effect";
+    accepts = "audio";
+    #context;
+    #box;
+    #parametric;
+    namedParameter; // let typescript infer the type
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+        this.#parametric = new ParameterAdapterSet(this.#context);
+        this.namedParameter = this.#wrapParameters(box);
+    }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get indexField() { return this.#box.index; }
+    get labelField() { return this.#box.label; }
+    get enabledField() { return this.#box.enabled; }
+    get minimizedField() { return this.#box.minimized; }
+    get host() { return this.#box.host; }
+    deviceHost() {
+        return this.#context.boxAdapters
+            .adapterFor(this.#box.host.targetVertex.unwrap("no device-host").box, Devices.isHost);
+    }
+    audioUnitBoxAdapter() { return this.deviceHost().audioUnitBoxAdapter(); }
+    terminate() { this.#parametric.terminate(); }
+    #wrapParameters(box) {
+        return {
+            delay: this.#parametric.createParameter(box.delay, ValueMapping.linearInteger(0, DelayDeviceBoxAdapter.OffsetFractions.length - 1), DelayDeviceBoxAdapter.OffsetStringMapping, "delay"),
+            feedback: this.#parametric.createParameter(box.feedback, ValueMapping.unipolar(), StringMapping.numeric({ unit: "%", fractionDigits: 0 }), "feedback"),
+            cross: this.#parametric.createParameter(box.cross, ValueMapping.unipolar(), StringMapping.numeric({ unit: "%", fractionDigits: 0 }), "cross"),
+            filter: this.#parametric.createParameter(box.filter, ValueMapping.bipolar(), StringMapping.numeric({ unit: "%", fractionDigits: 0 }), "filter", 0.5),
+            dry: this.#parametric.createParameter(box.dry, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db", fractionDigits: 1 }), "dry"),
+            wet: this.#parametric.createParameter(box.wet, ValueMapping.DefaultDecibel, StringMapping.numeric({ unit: "db", fractionDigits: 1 }), "wet")
+        };
+    }
+}

package/dist/devices/audio-effects/ModularDeviceBoxAdapter.d.ts

@@ -0,0 +1,31 @@
+import { ModularDeviceBox } from "@opendaw/studio-boxes";
+import { UUID } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { Address, BooleanField, FieldKeys, Int32Field, PointerField, StringField } from "@opendaw/lib-box";
+import { AudioEffectDeviceBoxAdapter, DeviceHost } from "../../devices";
+import { BoxAdaptersContext } from "../../BoxAdaptersContext";
+import { AutomatableParameterFieldAdapter } from "../../AutomatableParameterFieldAdapter";
+import { AudioUnitBoxAdapter } from "../../audio-unit/AudioUnitBoxAdapter";
+import { ModularAdapter } from "../../modular/modular";
+import { DeviceInterfaceKnobAdapter } from "../../modular/user-interface";
+export declare class ModularDeviceBoxAdapter implements AudioEffectDeviceBoxAdapter {
+    #private;
+    readonly type = "audio-effect";
+    readonly accepts = "audio";
+    constructor(context: BoxAdaptersContext, box: ModularDeviceBox);
+    get box(): ModularDeviceBox;
+    get uuid(): UUID.Format;
+    get address(): Address;
+    get indexField(): Int32Field;
+    get labelField(): StringField;
+    get enabledField(): BooleanField;
+    get minimizedField(): BooleanField;
+    get host(): PointerField<Pointers.AudioEffectHost>;
+    parameterAt(_fieldIndices: FieldKeys): AutomatableParameterFieldAdapter;
+    deviceHost(): DeviceHost;
+    audioUnitBoxAdapter(): AudioUnitBoxAdapter;
+    modular(): ModularAdapter;
+    elements(): ReadonlyArray<DeviceInterfaceKnobAdapter>;
+    terminate(): void;
+}
+//# sourceMappingURL=ModularDeviceBoxAdapter.d.ts.map

package/dist/devices/audio-effects/ModularDeviceBoxAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModularDeviceBoxAdapter.d.ts","sourceRoot":"","sources":["../../../src/devices/audio-effects/ModularDeviceBoxAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAA;AACtD,OAAO,EAAQ,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAC5C,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAC,MAAM,kBAAkB,CAAA;AACxG,OAAO,EAAC,2BAA2B,EAAE,UAAU,EAAU,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAC,kBAAkB,EAAC,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAC,gCAAgC,EAAC,MAAM,wCAAwC,CAAA;AACvF,OAAO,EAAC,mBAAmB,EAAC,MAAM,sCAAsC,CAAA;AACxE,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAC,0BAA0B,EAAC,MAAM,8BAA8B,CAAA;AAGvE,qBAAa,uBAAwB,YAAW,2BAA2B;;IACvE,QAAQ,CAAC,IAAI,kBAAiB;IAC9B,QAAQ,CAAC,OAAO,WAAU;gBAKd,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,gBAAgB;IAK9D,IAAI,GAAG,IAAI,gBAAgB,CAAmB;IAC9C,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,CAAgC;IACvD,IAAI,OAAO,IAAI,OAAO,CAA2B;IACjD,IAAI,UAAU,IAAI,UAAU,CAAyB;IACrD,IAAI,UAAU,IAAI,WAAW,CAAyB;IACtD,IAAI,YAAY,IAAI,YAAY,CAA2B;IAC3D,IAAI,cAAc,IAAI,YAAY,CAA6B;IAC/D,IAAI,IAAI,IAAI,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAwB;IAE1E,WAAW,CAAC,aAAa,EAAE,SAAS,GAAG,gCAAgC;IAEvE,UAAU,IAAI,UAAU;IAKxB,mBAAmB,IAAI,mBAAmB;IAE1C,OAAO,IAAI,cAAc;IAKzB,QAAQ,IAAI,aAAa,CAAC,0BAA0B,CAAC;IAKrD,SAAS,IAAI,IAAI;CACpB"}

package/dist/devices/audio-effects/ModularDeviceBoxAdapter.js

@@ -0,0 +1,38 @@
+import { panic } from "@opendaw/lib-std";
+import { Pointers } from "@opendaw/studio-enums";
+import { Devices } from "../../devices";
+import { ModularAdapter } from "../../modular/modular";
+import { DeviceInterfaceKnobAdapter } from "../../modular/user-interface";
+export class ModularDeviceBoxAdapter {
+    type = "audio-effect";
+    accepts = "audio";
+    #context;
+    #box;
+    constructor(context, box) {
+        this.#context = context;
+        this.#box = box;
+    }
+    get box() { return this.#box; }
+    get uuid() { return this.#box.address.uuid; }
+    get address() { return this.#box.address; }
+    get indexField() { return this.#box.index; }
+    get labelField() { return this.#box.label; }
+    get enabledField() { return this.#box.enabled; }
+    get minimizedField() { return this.#box.minimized; }
+    get host() { return this.#box.host; }
+    parameterAt(_fieldIndices) { return panic("Not yet implemented"); }
+    deviceHost() {
+        return this.#context.boxAdapters
+            .adapterFor(this.#box.host.targetVertex.unwrap("no device-host").box, Devices.isHost);
+    }
+    audioUnitBoxAdapter() { return this.deviceHost().audioUnitBoxAdapter(); }
+    modular() {
+        return this.#context.boxAdapters
+            .adapterFor(this.#box.modularSetup.targetVertex.unwrap("No Modular found").box, ModularAdapter);
+    }
+    elements() {
+        return this.#box.userInterface.elements.pointerHub.filter(Pointers.DeviceUserInterface)
+            .map(pointer => this.#context.boxAdapters.adapterFor(pointer.box, DeviceInterfaceKnobAdapter));
+    }
+    terminate() { }
+}