@opendaw/studio-core 0.0.19 → 0.0.21

package/dist/capture/RecordingContext.d.ts

@@ -0,0 +1,10 @@
+import { SampleManager } from "@opendaw/studio-adapters";
+import { Project } from "../Project";
+import { Worklets } from "../Worklets";
+export interface RecordingContext {
+    project: Project;
+    worklets: Worklets;
+    audioContext: AudioContext;
+    sampleManager: SampleManager;
+}
+//# sourceMappingURL=RecordingContext.d.ts.map

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

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

package/dist/capture/RecordingContext.js

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

package/dist/dawproject/AudioUnitExportLayout.d.ts

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

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

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

package/dist/dawproject/AudioUnitExportLayout.js

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

package/dist/dawproject/BuiltinDevices.d.ts

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

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

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

package/dist/dawproject/BuiltinDevices.js

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DawProject.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProject.ts"],"names":[],"mappings":"AAEA,OAAO,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"}

package/dist/dawproject/DawProject.js

@@ -0,0 +1,48 @@
+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";
+import { DawProjectExporter } from "./DawProjectExporter";
+export var DawProject;
+(function (DawProject) {
+    DawProject.decode = async (buffer) => {
+        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);
+        const projectXml = asDefined(await zip.file("project.xml")?.async("string"), "No project.xml found");
+        console.debug(projectXml);
+        const project = Xml.parse(projectXml, ProjectSchema);
+        const resourceFiles = Object.entries(zip.files).filter(([_, file]) => !file.dir && !file.name.endsWith(".xml"));
+        const resources = await Promise.all(resourceFiles.map(async ([path, file]) => {
+            const name = path.substring(path.lastIndexOf("/") + 1);
+            const buffer = await file.async("arraybuffer");
+            const uuid = await UUID.sha256(new Uint8Array(buffer).buffer);
+            return { uuid, path, name, buffer };
+        }));
+        return {
+            metaData, project, resources: {
+                fromPath: (path) => resources
+                    .find(resource => resource.path === path) ?? panic("Resource not found"),
+                fromUUID: (uuid) => resources
+                    .find(resource => UUID.equals(resource.uuid, uuid)) ?? panic("Resource not found")
+            }
+        };
+    };
+    DawProject.encode = (project, metaData) => {
+        const zip = new JSZip();
+        const projectSchema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                zip.file(path, buffer);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        const metaDataXml = Xml.pretty(Xml.toElement("MetaData", metaData));
+        const projectXml = Xml.pretty(Xml.toElement("Project", projectSchema));
+        console.debug("encode");
+        console.debug(metaDataXml);
+        console.debug(projectXml);
+        zip.file("metadata.xml", metaDataXml);
+        zip.file("project.xml", projectXml);
+        return zip.generateAsync({ type: "arraybuffer" });
+    };
+})(DawProject || (DawProject = {}));

package/dist/dawproject/DawProjectExporter.d.ts

@@ -1,8 +1,9 @@
-import { ProjectDecoder } from "@opendaw/studio-adapters";
-export declare class DawProjectExporter {
-    #private;
-    static exportProject(skeleton: ProjectDecoder.Skeleton): DawProjectExporter;
-    constructor(skeleton: ProjectDecoder.Skeleton);
-    toProjectXml(): string;
+import { FileReferenceSchema, ProjectSchema } from "@opendaw/lib-dawproject";
+import { Project } from "../Project";
+export declare namespace DawProjectExporter {
+    interface ResourcePacker {
+        write(path: string, buffer: ArrayBufferLike): FileReferenceSchema;
+    }
+    const write: (project: Project, resourcePacker: ResourcePacker) => ProjectSchema;
 }
 //# sourceMappingURL=DawProjectExporter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DawProjectExporter.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectExporter.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,cAAc,EAAC,MAAM,0BAA0B,CAAA;AAEvD,qBAAa,kBAAkB;;IAC3B,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,cAAc,CAAC,QAAQ,GAAG,kBAAkB;gBAM/D,QAAQ,EAAE,cAAc,CAAC,QAAQ;IAE7C,YAAY,IAAI,MAAM;CAoBzB"}
+{"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"}

package/dist/dawproject/DawProjectExporter.js

@@ -1,29 +1,252 @@
+import { asDefined, asInstanceOf, Color, ifDefined, isInstanceOf, Option, UUID } from "@opendaw/lib-std";
 import { Xml } from "@opendaw/lib-xml";
-import { ApplicationSchema, ArrangementSchema, ProjectSchema, RealParameterSchema, TransportSchema, Unit } from "@opendaw/lib-dawproject";
-export class DawProjectExporter {
-    static exportProject(skeleton) {
-        return new DawProjectExporter(skeleton);
-    }
-    #skeleton;
-    constructor(skeleton) { this.#skeleton = skeleton; }
-    toProjectXml() {
-        const { rootBox, timelineBox } = this.#skeleton.mandatoryBoxes;
-        const element = Xml.toElement("Project", Xml.element({
+import { dbToGain, PPQN } from "@opendaw/lib-dsp";
+import { ApplicationSchema, ArrangementSchema, AudioAlgorithm, AudioSchema, BuiltinDeviceSchema, ChannelRole, ChannelSchema, ClipSchema, ClipsSchema, DeviceRole, FileReferenceSchema, LanesSchema, NoteSchema, NotesSchema, ParameterEncoder, ProjectSchema, RealParameterSchema, TimeSignatureParameterSchema, TimeUnit, TrackSchema, TransportSchema, Unit, WarpSchema, WarpsSchema } from "@opendaw/lib-dawproject";
+import { AddressIdEncoder, BooleanField } from "@opendaw/lib-box";
+import { AudioUnitType } from "@opendaw/studio-enums";
+import { AudioFileBox, AudioUnitBox, NoteEventBox, NoteEventCollectionBox, TrackBox } from "@opendaw/studio-boxes";
+import { AudioUnitExportLayout } from "./AudioUnitExportLayout";
+import { ColorCodes } from "../ColorCodes";
+import { Html } from "@opendaw/lib-dom";
+import { encodeWavFloat } from "../Wav";
+import { DeviceBoxUtils } from "@opendaw/studio-adapters";
+import { DeviceIO } from "./DeviceIO";
+export var DawProjectExporter;
+(function (DawProjectExporter) {
+    DawProjectExporter.write = (project, resourcePacker) => {
+        const ids = new AddressIdEncoder();
+        const { boxGraph, timelineBox, rootBox, sampleManager } = project;
+        const audioUnits = rootBox.audioUnits.pointerHub.incoming()
+            .map(({ box }) => asInstanceOf(box, AudioUnitBox))
+            .sort((a, b) => a.index.getValue() - b.index.getValue());
+        boxGraph.boxes().forEach(box => box.accept({
+            visitAudioFileBox: (box) => sampleManager.getOrCreate(box.address.uuid).data
+                .ifSome(({ frames, numberOfFrames, sampleRate, numberOfChannels }) => resourcePacker.write(`samples/${box.fileName.getValue()}.wav`, encodeWavFloat({
+                channels: frames,
+                duration: numberOfFrames * sampleRate,
+                numberOfChannels,
+                sampleRate,
+                numFrames: numberOfFrames
+            })))
+        }));
+        const writeTransport = () => Xml.element({
+            tempo: Xml.element({
+                id: ids.getOrCreate(timelineBox.bpm.address),
+                value: timelineBox.bpm.getValue(),
+                unit: Unit.BPM
+            }, RealParameterSchema),
+            timeSignature: Xml.element({
+                numerator: timelineBox.signature.nominator.getValue(),
+                denominator: timelineBox.signature.denominator.getValue()
+            }, TimeSignatureParameterSchema)
+        }, TransportSchema);
+        const writeDevices = (field, deviceRole) => field.pointerHub
+            .incoming().map(({ box }) => {
+            const enabled = ("enabled" in box && isInstanceOf(box.enabled, BooleanField)
+                ? Option.wrap(box.enabled)
+                : Option.None)
+                .mapOr(field => ParameterEncoder.bool(ids.getOrCreate(field.address), field.getValue(), "On/Off"), undefined);
+            const deviceID = box.name;
+            const deviceName = DeviceBoxUtils.lookupLabelField(box).getValue();
+            const deviceVendor = "openDAW";
+            const id = ids.getOrCreate(box.address);
+            return Xml.element({
+                id,
+                deviceID,
+                deviceRole,
+                deviceName,
+                deviceVendor,
+                enabled,
+                loaded: true,
+                automatedParameters: [],
+                state: resourcePacker
+                    .write(`presets/${UUID.toString(box.address.uuid)}`, DeviceIO.exportDevice(box))
+            }, BuiltinDeviceSchema);
+        });
+        const colorForAudioType = (unitType) => {
+            const cssColor = ColorCodes.forAudioType(unitType);
+            if (cssColor === "") {
+                return "red";
+            }
+            const [r, g, b] = Html.readCssVarColor(ColorCodes.forAudioType(unitType))[0];
+            const RR = Math.round(r * 255).toString(16).padStart(2, "0");
+            const GG = Math.round(g * 255).toString(16).padStart(2, "0");
+            const BB = Math.round(b * 255).toString(16).padStart(2, "0");
+            return `#${RR}${GG}${BB}`;
+        };
+        const writeStructure = () => {
+            const tracks = AudioUnitExportLayout.layout(audioUnits);
+            const writeAudioUnitBox = (audioUnitBox, tracks) => {
+                const unitType = audioUnitBox.type.getValue();
+                const color = colorForAudioType(unitType);
+                const isPrimary = unitType === AudioUnitType.Output;
+                const isAux = unitType === AudioUnitType.Aux;
+                const inputBox = audioUnitBox.input.pointerHub.incoming().at(0)?.box;
+                const contentType = isPrimary ? "audio notes" // we copied that value from bitwig
+                    : isAux ? "audio" : (() => 
+                    // TODO Another location to remember to put devices in...?
+                    //  We could also read the first track type?
+                    inputBox?.accept({
+                        visitTapeDeviceBox: () => "audio",
+                        visitVaporisateurDeviceBox: () => "notes",
+                        visitNanoDeviceBox: () => "notes",
+                        visitPlayfieldDeviceBox: () => "notes",
+                        visitAudioBusBox: () => "tracks"
+                    }))() ?? undefined;
+                return Xml.element({
+                    id: ids.getOrCreate(audioUnitBox.address),
+                    name: DeviceBoxUtils.lookupLabelField(inputBox).getValue(),
+                    loaded: true,
+                    color,
+                    contentType,
+                    channel: Xml.element({
+                        id: ifDefined(inputBox, ({ address }) => ids.getOrCreate(address)),
+                        destination: isPrimary
+                            ? undefined
+                            : audioUnitBox.output.targetVertex
+                                .mapOr(({ box }) => ids.getOrCreate(box.address), undefined),
+                        role: (() => {
+                            switch (unitType) {
+                                case AudioUnitType.Instrument:
+                                    return ChannelRole.REGULAR;
+                                case AudioUnitType.Aux:
+                                    return ChannelRole.EFFECT;
+                                case AudioUnitType.Bus:
+                                case AudioUnitType.Output:
+                                    return ChannelRole.MASTER;
+                            }
+                        })(),
+                        devices: [
+                            ...(writeDevices(audioUnitBox.midiEffects, DeviceRole.NOTE_FX)),
+                            ...(writeDevices(audioUnitBox.input, DeviceRole.INSTRUMENT)),
+                            ...(writeDevices(audioUnitBox.audioEffects, DeviceRole.AUDIO_FX))
+                        ],
+                        volume: ParameterEncoder.linear(ids.getOrCreate(audioUnitBox.volume.address), dbToGain(audioUnitBox.volume.getValue()), 0.0, 2.0, "Volume"),
+                        pan: ParameterEncoder.normalized(ids.getOrCreate(audioUnitBox.panning.address), (audioUnitBox.panning.getValue() + 1.0) / 2.0, 0.0, 1.0, "Pan")
+                    }, ChannelSchema),
+                    tracks
+                }, TrackSchema);
+            };
+            const writeTracks = (tracks) => tracks.map((track) => writeAudioUnitBox(track.audioUnit, writeTracks(track.children)));
+            return writeTracks(tracks);
+        };
+        const writeAudioRegion = (region) => {
+            const audioFileBox = asInstanceOf(region.file.targetVertex.unwrap("No file at region").box, AudioFileBox);
+            const audioElement = sampleManager.getOrCreate(audioFileBox.address.uuid).data
+                .map(({ numberOfFrames, sampleRate, numberOfChannels }) => Xml.element({
+                duration: numberOfFrames / sampleRate,
+                channels: numberOfChannels,
+                sampleRate,
+                algorithm: AudioAlgorithm.REPITCH,
+                file: Xml.element({
+                    path: `samples/${audioFileBox.fileName.getValue()}.wav`,
+                    external: false
+                }, FileReferenceSchema)
+            }, AudioSchema));
+            const duration = region.duration.getValue() / PPQN.Quarter;
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                content: audioElement.mapOr(element => [element], []),
+                                contentTimeUnit: "beats",
+                                warps: [
+                                    Xml.element({
+                                        time: 0.0,
+                                        contentTime: 0.0
+                                    }, WarpSchema),
+                                    Xml.element({
+                                        time: duration,
+                                        contentTime: audioElement.mapOr(element => element.duration, 0)
+                                    }, WarpSchema)
+                                ]
+                            }, WarpsSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        const writeNoteRegion = (region) => {
+            const collectionBox = asInstanceOf(region.events.targetVertex
+                .unwrap("No notes in region").box, NoteEventCollectionBox);
+            return Xml.element({
+                clips: [Xml.element({
+                        time: region.position.getValue() / PPQN.Quarter,
+                        duration: region.duration.getValue() / PPQN.Quarter,
+                        contentTimeUnit: TimeUnit.BEATS,
+                        playStart: 0.0,
+                        loopStart: 0.0,
+                        loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                        enable: !region.mute.getValue(),
+                        name: region.label.getValue(),
+                        color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                        content: [Xml.element({
+                                notes: collectionBox.events.pointerHub.incoming()
+                                    .map(({ box }) => asInstanceOf(box, NoteEventBox))
+                                    .map(box => Xml.element({
+                                    time: box.position.getValue() / PPQN.Quarter,
+                                    duration: box.duration.getValue() / PPQN.Quarter,
+                                    key: box.pitch.getValue(),
+                                    channel: 0,
+                                    vel: box.velocity.getValue(),
+                                    rel: box.velocity.getValue()
+                                }, NoteSchema))
+                            }, NotesSchema)]
+                    }, ClipSchema)]
+            }, ClipsSchema);
+        };
+        // TODO Implement!
+        const writeValueRegion = (region) => Xml.element({
+            clips: [Xml.element({
+                    time: region.position.getValue() / PPQN.Quarter,
+                    duration: region.duration.getValue() / PPQN.Quarter,
+                    contentTimeUnit: TimeUnit.BEATS,
+                    playStart: 0.0,
+                    loopStart: 0.0,
+                    loopEnd: region.loopDuration.getValue() / PPQN.Quarter,
+                    enable: !region.mute.getValue(),
+                    name: region.label.getValue(),
+                    color: Color.hslToHex(region.hue.getValue(), 1.0, 0.60),
+                    content: []
+                }, ClipSchema)]
+        }, ClipsSchema);
+        const writeLanes = () => {
+            return audioUnits
+                .flatMap(audioUnitBox => audioUnitBox.tracks.pointerHub.incoming()
+                .map(({ box }) => asInstanceOf(box, TrackBox))
+                .sort((a, b) => a.index.getValue() - b.index.getValue())
+                .map(trackBox => Xml.element({
+                id: ids.getOrCreate(trackBox.address),
+                track: ids.getOrCreate(audioUnitBox.address),
+                lanes: trackBox.regions.pointerHub.incoming()
+                    .map(({ box }) => asDefined(box.accept({
+                    visitAudioRegionBox: (region) => writeAudioRegion(region),
+                    visitNoteRegionBox: (region) => writeNoteRegion(region),
+                    visitValueRegionBox: (region) => writeValueRegion(region)
+                }), "Could not write region."))
+            }, LanesSchema)));
+        };
+        return Xml.element({
             version: "1.0",
             application: Xml.element({
                 name: "openDAW",
                 version: "0.1"
             }, ApplicationSchema),
-            transport: Xml.element({
-                tempo: Xml.element({
-                    value: timelineBox.bpm.getValue(),
-                    unit: Unit.BPM
-                }, RealParameterSchema)
-            }, TransportSchema),
-            structure: [],
-            arrangement: Xml.element({}, ArrangementSchema),
+            transport: writeTransport(),
+            structure: writeStructure(),
+            arrangement: Xml.element({
+                lanes: Xml.element({
+                    lanes: writeLanes(),
+                    timeUnit: TimeUnit.BEATS
+                }, LanesSchema)
+            }, ArrangementSchema),
             scenes: []
-        }, ProjectSchema));
-        return Xml.pretty(element);
-    }
-}
+        }, ProjectSchema);
+    };
+})(DawProjectExporter || (DawProjectExporter = {}));

package/dist/dawproject/DawProjectExporter.test.js

@@ -2,15 +2,47 @@ import { describe, it } from "vitest";
 import { fileURLToPath } from "url";
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { ProjectDecoder } from "@opendaw/studio-adapters";
-import { ProjectMigration } from "../ProjectMigration";
+import { Project } from "../Project";
+import { Option, panic, Terminable } from "@opendaw/lib-std";
+import { Xml } from "@opendaw/lib-xml";
+import { FileReferenceSchema } from "@opendaw/lib-dawproject";
 import { DawProjectExporter } from "./DawProjectExporter";
 describe("DawProjectExport", () => {
     it("export", async () => {
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const buffer = fs.readFileSync(path.join(__dirname, "../../../../../packages/app/studio/public/templates/Fatso.od"));
-        const skeleton = ProjectDecoder.decode(buffer.buffer);
-        ProjectMigration.migrate(skeleton);
-        console.debug(DawProjectExporter.exportProject(skeleton).toProjectXml());
+        const projectPath = "../../../../../test-files/all-devices.od";
+        const buffer = fs.readFileSync(path.join(__dirname, projectPath));
+        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        const project = Project.load({
+            sampleManager: new class {
+                record(_loader) {
+                    throw new Error("Method not implemented.");
+                }
+                getOrCreate(format) {
+                    return new class {
+                        data = Option.None;
+                        peaks = Option.None;
+                        uuid = format;
+                        state = { type: "progress", progress: 0.0 };
+                        meta = Option.None;
+                        invalidate() { throw new Error("Method not implemented."); }
+                        subscribe(_observer) {
+                            return Terminable.Empty;
+                        }
+                    };
+                }
+                invalidate(_uuid) {
+                    return panic("Method not implemented.");
+                }
+            }
+        }, arrayBuffer);
+        const schema = DawProjectExporter.write(project, {
+            write: (path, buffer) => {
+                console.debug(`store ${buffer.byteLength} bytes at ${path}`);
+                return Xml.element({ path, external: false }, FileReferenceSchema);
+            }
+        });
+        // console.dir(schema, {depth: Number.MAX_SAFE_INTEGER})
+        console.debug(Xml.pretty(Xml.toElement("Project", schema)));
     });
 });

package/dist/dawproject/DawProjectImport.d.ts

@@ -0,0 +1,12 @@
+import { UUID } from "@opendaw/lib-std";
+import { ProjectSchema } from "@opendaw/lib-dawproject";
+import { ProjectDecoder } from "@opendaw/studio-adapters";
+import { DawProject } from "./DawProject";
+export declare namespace DawProjectImport {
+    type Result = {
+        audioIds: ReadonlyArray<UUID.Format>;
+        skeleton: ProjectDecoder.Skeleton;
+    };
+    const read: (schema: ProjectSchema, resources: DawProject.ResourceProvider) => Promise<Result>;
+}
+//# sourceMappingURL=DawProjectImport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DawProjectImport.d.ts","sourceRoot":"","sources":["../../src/dawproject/DawProjectImport.ts"],"names":[],"mappings":"AAAA,OAAO,EAgBH,IAAI,EAEP,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAcH,aAAa,EAOhB,MAAM,yBAAyB,CAAA;AAuBhC,OAAO,EAAyC,cAAc,EAAY,MAAM,0BAA0B,CAAA;AAC1G,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAA;AAQvC,yBAAiB,gBAAgB,CAAC;IAW9B,KAAY,MAAM,GAAG;QACjB,QAAQ,EAAE,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAA;KACpC,CAAA;IAOM,MAAM,IAAI,GAAU,QAAQ,aAAa,EAAE,WAAW,UAAU,CAAC,gBAAgB,KAAG,OAAO,CAAC,MAAM,CA6WxG,CAAA;CAaJ"}