@opendaw/studio-core 0.0.25 → 0.0.27

package/dist/clouds/CloudAuthManager.js

@@ -0,0 +1,195 @@
+import { asDefined, Errors, isDefined, isNull, Maps, panic, RuntimeNotifier, TimeSpan } from "@opendaw/lib-std";
+import { Promises } from "@opendaw/lib-runtime";
+export class CloudAuthManager {
+    static create() { return new CloudAuthManager(); }
+    static async #createCodes() {
+        const array = new Uint8Array(32);
+        crypto.getRandomValues(array);
+        const codeVerifier = btoa(String.fromCharCode(...array))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+        const encoder = new TextEncoder();
+        const data = encoder.encode(codeVerifier);
+        const digest = await crypto.subtle.digest("SHA-256", data);
+        const codeChallenge = btoa(String.fromCharCode(...new Uint8Array(digest)))
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+        return { codeVerifier, codeChallenge };
+    }
+    static #ID = 0;
+    id = CloudAuthManager.#ID++;
+    #memoizedHandlers = new Map();
+    constructor() { }
+    async getHandler(service) {
+        const memo = Maps.createIfAbsent(this.#memoizedHandlers, service, service => {
+            switch (service) {
+                case "Dropbox": {
+                    return Promises.memoizeAsync(this.#oauthDropbox.bind(this), TimeSpan.hours(1));
+                }
+                case "GoogleDrive": {
+                    return Promises.memoizeAsync(this.#oauthGoogle.bind(this), TimeSpan.hours(1));
+                }
+                default:
+                    return panic(`Unsupported service: ${service}`);
+            }
+        });
+        const handler = await memo();
+        const { status } = await Promises.tryCatch(handler.alive());
+        if (status === "rejected") {
+            this.#memoizedHandlers.delete(service);
+            return this.getHandler(service);
+        }
+        console.debug(`Handler for '${service}' is alive`);
+        return handler;
+    }
+    async #oauthPkceFlow(config) {
+        const redirectUri = `${location.origin}/auth-callback.html`;
+        const { codeVerifier, codeChallenge } = await CloudAuthManager.#createCodes();
+        const params = new URLSearchParams({
+            client_id: config.clientId,
+            response_type: "code",
+            redirect_uri: redirectUri,
+            scope: config.scope,
+            code_challenge: codeChallenge,
+            code_challenge_method: "S256",
+            ...(config.extraAuthParams ?? {})
+        });
+        const authUrl = `${config.authUrlBase}?${params.toString()}`;
+        console.debug("[CloudAuth] Opening auth window:", authUrl);
+        const authWindow = window.open(authUrl, "cloudAuth");
+        if (isNull(authWindow)) {
+            return Errors.warn("Failed to open authentication window. Please check popup blockers.");
+        }
+        const { resolve, reject, promise } = Promise.withResolvers();
+        const channel = new BroadcastChannel("auth-callback");
+        const dialog = RuntimeNotifier.progress({
+            headline: "Cloud Service",
+            message: "Please wait for authentication...",
+            cancel: () => reject("cancelled")
+        });
+        channel.onmessage = async (event) => {
+            const data = asDefined(event.data, "No data");
+            console.debug("[CloudAuth] Received via BroadcastChannel:", this.id, data);
+            if (data.type === "auth-callback" && isDefined(data.code)) {
+                console.debug("[CloudAuth] Processing code from BroadcastChannel...", data.type, data.code);
+                try {
+                    const tokenParams = new URLSearchParams({
+                        code: data.code,
+                        grant_type: "authorization_code",
+                        client_id: config.clientId,
+                        redirect_uri: redirectUri,
+                        code_verifier: codeVerifier,
+                        ...(config.extraTokenParams ?? {})
+                    });
+                    const response = await fetch(config.tokenUrl, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                        body: tokenParams.toString()
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        console.error("[CloudAuth] Token exchange error:", errorText);
+                        return panic(`Token exchange failed: ${response.statusText}`);
+                    }
+                    const dataJson = await response.json();
+                    const accessToken = dataJson.access_token;
+                    if (!accessToken) {
+                        return panic("No access_token in token response");
+                    }
+                    resolve(await this.#createHandler(config.service, accessToken));
+                }
+                catch (err) {
+                    console.debug("[CloudAuth] Token exchange failed:", err);
+                    reject(err);
+                }
+            }
+            else if (data.type === "closed") {
+                console.debug("[CloudAuth] Callback window closed");
+                reject(null);
+            }
+        };
+        return promise.finally(() => {
+            console.debug("[CloudAuth] Closing auth window");
+            authWindow.close();
+            dialog.terminate();
+            channel.close();
+        });
+    }
+    async #oauthDropbox() {
+        return this.#oauthPkceFlow({
+            service: "dropbox",
+            clientId: "jtehjzxaxf3bf1l",
+            authUrlBase: "https://www.dropbox.com/oauth2/authorize",
+            tokenUrl: "https://api.dropboxapi.com/oauth2/token",
+            scope: "", // Dropbox scope is optional
+            extraAuthParams: {
+                token_access_type: "offline"
+            }
+        });
+    }
+    async #oauthGoogle() {
+        const clientId = "628747153367-gt1oqcn3trr9l9a7jhigja6l1t3f1oik.apps.googleusercontent.com";
+        const scope = "https://www.googleapis.com/auth/drive.appdata";
+        const redirectUri = `${location.origin}/auth-callback.html`;
+        const params = new URLSearchParams({
+            client_id: clientId,
+            response_type: "token",
+            redirect_uri: redirectUri,
+            scope,
+            include_granted_scopes: "true",
+            prompt: "consent"
+        });
+        const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+        console.debug("[CloudAuth] Opening auth window:", authUrl);
+        const authWindow = window.open(authUrl, "cloudAuth");
+        if (isNull(authWindow)) {
+            return Errors.warn("Failed to open authentication window. Please check popup blockers.");
+        }
+        const { resolve, reject, promise } = Promise.withResolvers();
+        const channel = new BroadcastChannel("auth-callback");
+        const dialog = RuntimeNotifier.progress({
+            headline: "Google Drive",
+            message: "Please authorize access to app data...",
+            cancel: () => reject("cancelled")
+        });
+        channel.onmessage = async (event) => {
+            const data = asDefined(event.data, "No data");
+            console.debug("[CloudAuth] Received via BroadcastChannel:", this.id, data);
+            if (data.type === "auth-callback" && isDefined(data.access_token)) {
+                try {
+                    const accessToken = data.access_token;
+                    resolve(await this.#createHandler("google", accessToken));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }
+            else if (data.type === "closed") {
+                console.debug("[CloudAuth] Callback window closed");
+                reject(null);
+            }
+        };
+        return promise.finally(() => {
+            console.debug("[CloudAuth] Closing auth window");
+            authWindow.close();
+            dialog.terminate();
+            channel.close();
+        });
+    }
+    async #createHandler(service, token) {
+        switch (service) {
+            case "dropbox": {
+                const { DropboxHandler } = await import("./DropboxHandler");
+                return new DropboxHandler(token);
+            }
+            case "google": {
+                const { GoogleDriveHandler } = await import("./GoogleDriveHandler");
+                return new GoogleDriveHandler(token);
+            }
+            default:
+                return panic(`Handler not implemented for service: ${service}`);
+        }
+    }
+}

package/dist/clouds/CloudBackup.d.ts

@@ -0,0 +1,8 @@
+import { CloudHandler } from "./CloudHandler";
+import { CloudAuthManager } from "./CloudAuthManager";
+import { CloudService } from "./CloudService";
+export declare namespace CloudBackup {
+    const backup: (cloudAuthManager: CloudAuthManager, service: CloudService) => Promise<void>;
+    const backupWithHandler: (cloudHandler: CloudHandler, service: CloudService) => Promise<void>;
+}
+//# sourceMappingURL=CloudBackup.d.ts.map

package/dist/clouds/CloudBackup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudBackup.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudBackup.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAG3C,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAG3C,yBAAiB,WAAW,CAAC;IAClB,MAAM,MAAM,GAAU,kBAAkB,gBAAgB,EAAE,SAAS,YAAY,kBA8BrF,CAAA;IAEM,MAAM,iBAAiB,GAAU,cAAc,YAAY,EAAE,SAAS,YAAY,kBAYxF,CAAA;CACJ"}

package/dist/clouds/CloudBackup.js

@@ -0,0 +1,55 @@
+import { DefaultObservableValue, Progress, RuntimeNotifier, RuntimeSignal } from "@opendaw/lib-std";
+import { CloudBackupSamples } from "./CloudBackupSamples";
+import { CloudBackupProjects } from "./CloudBackupProjects";
+import { ProjectSignals } from "../project/ProjectSignals";
+export var CloudBackup;
+(function (CloudBackup) {
+    CloudBackup.backup = async (cloudAuthManager, service) => {
+        const DialogMessage = `openDAW will never store or share your personal account details!
+                                        
+                                        Dropbox requires permission to read “basic account info” such as your name and email, but openDAW does not use or retain this information. We only access the files you choose to synchronize. 
+                                        
+                                        Clicking 'Sync' may open a new tab to authorize your dropbox.`;
+        const approved = await RuntimeNotifier.approve({
+            headline: "openDAW and your data",
+            message: DialogMessage,
+            approveText: "Sync",
+            cancelText: "Cancel"
+        });
+        if (!approved) {
+            return;
+        }
+        try {
+            const handler = await cloudAuthManager.getHandler(service);
+            await CloudBackup.backupWithHandler(handler, service);
+            await RuntimeNotifier.info({
+                headline: "Cloud Backup",
+                message: "Everything is up to date."
+            });
+        }
+        catch (reason) {
+            console.warn(reason);
+            await RuntimeNotifier.info({
+                headline: `Could not sync`,
+                message: String(reason)
+            });
+        }
+        finally {
+            RuntimeSignal.dispatch(ProjectSignals.StorageUpdated);
+        }
+    };
+    CloudBackup.backupWithHandler = async (cloudHandler, service) => {
+        const progressValue = new DefaultObservableValue(0.0);
+        const notification = RuntimeNotifier.progress({ headline: `Backup with ${service}`, progress: progressValue });
+        const log = (text) => notification.message = text;
+        const [progressSamples, progressProjects] = Progress.split(progress => progressValue.setValue(progress), 2);
+        try {
+            await CloudBackupSamples.start(cloudHandler, progressSamples, log);
+            await CloudBackupProjects.start(cloudHandler, progressProjects, log);
+        }
+        finally {
+            progressValue.terminate();
+            notification.terminate();
+        }
+    };
+})(CloudBackup || (CloudBackup = {}));

package/dist/clouds/CloudBackupProjects.d.ts

@@ -0,0 +1,10 @@
+import { Procedure, Progress } from "@opendaw/lib-std";
+import { CloudHandler } from "./CloudHandler";
+export declare class CloudBackupProjects {
+    #private;
+    static readonly RemotePath = "projects";
+    static readonly RemoteCatalogPath: string;
+    static start(cloudHandler: CloudHandler, progress: Progress.Handler, log: Procedure<string>): Promise<void>;
+    private constructor();
+}
+//# sourceMappingURL=CloudBackupProjects.d.ts.map

package/dist/clouds/CloudBackupProjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudBackupProjects.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudBackupProjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,SAAS,EACT,QAAQ,EAKX,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAY3C,qBAAa,mBAAmB;;IAC5B,MAAM,CAAC,QAAQ,CAAC,UAAU,cAAa;IACvC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,SAAkC;WAEtD,KAAK,CAAC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAC1B,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC;IAmBzC,OAAO;CAyJV"}

package/dist/clouds/CloudBackupProjects.js

@@ -0,0 +1,167 @@
+import { Arrays, Errors, isAbsent, Objects, panic, Progress, RuntimeNotifier, TimeSpan, UUID } from "@opendaw/lib-std";
+import { network, Promises } from "@opendaw/lib-runtime";
+import { ProjectStorage } from "../project/ProjectStorage";
+import { WorkerAgents } from "../WorkerAgents";
+import { ProjectPaths } from "../project/ProjectPaths";
+// these get indexed in the cloud with the uuid in the cloud's catalog
+const catalogFields = ["name", "modified", "created", "tags", "description"];
+export class CloudBackupProjects {
+    static RemotePath = "projects";
+    static RemoteCatalogPath = `${this.RemotePath}/index.json`;
+    static async start(cloudHandler, progress, log) {
+        log("Collecting all project domains...");
+        const [local, cloud] = await Promise.all([
+            ProjectStorage.listProjects()
+                .then(list => list.reduce((record, entry) => {
+                record[UUID.toString(entry.uuid)] = Objects.include(entry.meta, ...catalogFields);
+                return record;
+            }, {})),
+            cloudHandler.download(CloudBackupProjects.RemoteCatalogPath)
+                .then(json => JSON.parse(new TextDecoder().decode(json)))
+                .catch(reason => reason instanceof Errors.FileNotFound ? Arrays.empty() : panic(reason))
+        ]);
+        return new CloudBackupProjects(cloudHandler, { local, cloud }, log).#start(progress);
+    }
+    #cloudHandler;
+    #projectDomains;
+    #log;
+    constructor(cloudHandler, projectDomains, log) {
+        this.#cloudHandler = cloudHandler;
+        this.#projectDomains = projectDomains;
+        this.#log = log;
+    }
+    async #start(progress) {
+        const trashed = await ProjectStorage.loadTrashedIds();
+        const [uploadProgress, trashProgress, downloadProgress] = Progress.splitWithWeights(progress, [0.45, 0.10, 0.45]);
+        await this.#upload(uploadProgress);
+        await this.#trash(trashed, trashProgress);
+        await this.#download(trashed, downloadProgress);
+    }
+    async #upload(progress) {
+        const { local, cloud } = this.#projectDomains;
+        const isUnsynced = (localProject, cloudProject) => isAbsent(cloudProject)
+            || new Date(cloudProject.modified).getTime() < new Date(localProject.modified).getTime();
+        const unsyncedProjects = Object.entries(local)
+            .filter(([uuid, localProject]) => isUnsynced(localProject, cloud[uuid]))
+            .map(([uuid, localProject]) => ([UUID.asString(uuid), localProject]));
+        if (unsyncedProjects.length === 0) {
+            this.#log("No unsynced projects found.");
+            progress(1.0);
+            return;
+        }
+        const uploaded = await Promises.sequentialAll(unsyncedProjects
+            .map(([uuidAsString, meta], index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Uploading project '${meta.name}'`);
+            const uuid = UUID.parse(uuidAsString);
+            const folder = `${CloudBackupProjects.RemotePath}/${uuidAsString}`;
+            const metaFile = await ProjectStorage.loadMeta(uuid);
+            const projectFile = await ProjectStorage.loadProject(uuid);
+            const optCoverFile = await ProjectStorage.loadCover(uuid);
+            const tasks = [];
+            const removeProjectPath = `${folder}/project.od`;
+            const remoteMetaPath = `${folder}/meta.json`;
+            tasks.push(() => this.#cloudHandler.upload(removeProjectPath, projectFile));
+            tasks.push(() => this.#cloudHandler.upload(remoteMetaPath, metaFile));
+            optCoverFile.ifSome(cover => {
+                const removeCoverPath = `${folder}/image.bin`;
+                return tasks.push(() => this.#cloudHandler.upload(removeCoverPath, cover));
+            });
+            await Promises.approvedRetry(() => Promises.timeout(Promises.sequentialAll(tasks), TimeSpan.minutes(10), "Upload timeout (10 min)."), error => ({
+                headline: "Upload failed",
+                message: `Failed to upload project '${meta.name}'. '${error}'`,
+                approveText: "Retry",
+                cancelText: "Cancel"
+            }));
+            return { uuidAsString, meta };
+        }));
+        const catalog = uploaded
+            .reduce((projects, project) => {
+            projects[UUID.asString(project.uuidAsString)] = project.meta;
+            return projects;
+        }, { ...cloud });
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #trash(trashed, progress) {
+        const { cloud } = this.#projectDomains;
+        const obsolete = Arrays.intersect(Object.entries(cloud), trashed, ([uuid, _], trashed) => uuid === trashed);
+        if (obsolete.length > 0) {
+            const approved = await RuntimeNotifier.approve({
+                headline: "Delete Projects?",
+                message: `Found ${obsolete.length} locally deleted projects. Delete from cloud as well?`,
+                approveText: "Yes",
+                cancelText: "No"
+            });
+            if (approved) {
+                const deleted = await Promises.sequentialAll(obsolete.map(([uuid, meta], index, { length }) => async () => {
+                    progress((index + 1) / length);
+                    const path = `${CloudBackupProjects.RemotePath}/${uuid}`;
+                    this.#log(`Deleting '${meta.name}'`);
+                    await this.#cloudHandler.delete(path);
+                    return UUID.asString(uuid);
+                }));
+                const catalog = { ...cloud };
+                deleted.forEach(uuid => delete catalog[uuid]);
+                await this.#uploadCatalog(catalog);
+            }
+        }
+        progress(1.0);
+    }
+    async #download(trashed, progress) {
+        const { cloud, local } = this.#projectDomains;
+        const compareFn = ([uuidA], [uuidB]) => uuidA === uuidB;
+        const missingLocally = Arrays.subtract(Object.entries(cloud), Object.entries(local), compareFn);
+        const download = Arrays.subtract(missingLocally, trashed, ([projectUUID], uuid) => projectUUID === uuid);
+        if (download.length === 0) {
+            this.#log("No projects to download.");
+            progress(1.0);
+            return;
+        }
+        await Promises.sequentialAll(download.map(([uuidAsString, meta], index, { length }) => async () => {
+            progress((index + 1) / length);
+            const uuid = UUID.parse(uuidAsString);
+            const path = `${CloudBackupProjects.RemotePath}/${uuidAsString}`;
+            this.#log(`Downloading project '${meta.name}'`);
+            const files = await Promises.guardedRetry(() => this.#cloudHandler.list(path), network.DefaultRetry);
+            const hasProjectFile = files.includes("project.od");
+            const hasMetaFile = files.includes("meta.json");
+            if (!hasProjectFile || !hasMetaFile) {
+                console.warn(`hasProjectFile: ${hasProjectFile}, hasMetaFile: ${hasMetaFile} for ${uuidAsString}`);
+                const approvedDeletion = await RuntimeNotifier.approve({
+                    headline: "Download failed",
+                    message: `Project '${meta.name}' is corrupted. Delete it from cloud?.`,
+                    approveText: "Yes",
+                    cancelText: "Ignore"
+                });
+                if (approvedDeletion) {
+                    await this.#cloudHandler.delete(path);
+                }
+                else {
+                    return uuidAsString;
+                }
+            }
+            const projectPath = `${path}/project.od`;
+            const metaPath = `${path}/meta.json`;
+            const coverPath = `${path}/image.bin`;
+            const projectArrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(projectPath), network.DefaultRetry);
+            const metaArrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(metaPath), network.DefaultRetry);
+            await WorkerAgents.Opfs.write(ProjectPaths.projectFile(uuid), new Uint8Array(projectArrayBuffer));
+            await WorkerAgents.Opfs.write(ProjectPaths.projectMeta(uuid), new Uint8Array(metaArrayBuffer));
+            const hasCover = files.some(file => file.endsWith("image.bin"));
+            if (hasCover) {
+                const arrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(coverPath), network.DefaultRetry);
+                await WorkerAgents.Opfs.write(ProjectPaths.projectCover(uuid), new Uint8Array(arrayBuffer));
+            }
+            return uuidAsString;
+        }));
+        this.#log("Download projects complete.");
+        progress(1.0);
+    }
+    async #uploadCatalog(catalog) {
+        this.#log("Uploading project catalog...");
+        const jsonString = JSON.stringify(catalog, null, 2);
+        const buffer = new TextEncoder().encode(jsonString).buffer;
+        return this.#cloudHandler.upload(CloudBackupProjects.RemoteCatalogPath, buffer);
+    }
+}

package/dist/clouds/CloudBackupSamples.d.ts

@@ -0,0 +1,13 @@
+import { Procedure, Progress, UUID } from "@opendaw/lib-std";
+import { Sample } from "@opendaw/studio-adapters";
+import { CloudHandler } from "./CloudHandler";
+export declare class CloudBackupSamples {
+    #private;
+    static readonly RemotePath = "samples";
+    static readonly RemoteCatalogPath: string;
+    static readonly areSamplesEqual: ({ uuid: a }: Sample, { uuid: b }: Sample) => boolean;
+    static pathFor(uuid: UUID.String): string;
+    static start(cloudHandler: CloudHandler, progress: Progress.Handler, log: Procedure<string>): Promise<void>;
+    private constructor();
+}
+//# sourceMappingURL=CloudBackupSamples.d.ts.map

package/dist/clouds/CloudBackupSamples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudBackupSamples.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudBackupSamples.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,SAAS,EAAE,QAAQ,EAAmB,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAGlG,OAAO,EAAY,MAAM,EAAC,MAAM,0BAA0B,CAAA;AAG1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAM3C,qBAAa,kBAAkB;;IAC3B,MAAM,CAAC,QAAQ,CAAC,UAAU,aAAY;IACtC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,SAAkC;IACnE,MAAM,CAAC,QAAQ,CAAC,eAAe,GAAI,aAAW,MAAM,EAAE,aAAW,MAAM,aAAY;IAEnF,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM;WAE5B,KAAK,CAAC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAC1B,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC;IAgBzC,OAAO;CAsHV"}

package/dist/clouds/CloudBackupSamples.js

@@ -0,0 +1,129 @@
+import { Arrays, Errors, panic, Progress, RuntimeNotifier, UUID } from "@opendaw/lib-std";
+import { network, Promises } from "@opendaw/lib-runtime";
+import { SamplePeaks } from "@opendaw/lib-fusion";
+import { OpenSampleAPI } from "../samples/OpenSampleAPI";
+import { SampleStorage } from "../samples/SampleStorage";
+import { WorkerAgents } from "../WorkerAgents";
+import { WavFile } from "../WavFile";
+export class CloudBackupSamples {
+    static RemotePath = "samples";
+    static RemoteCatalogPath = `${this.RemotePath}/index.json`;
+    static areSamplesEqual = ({ uuid: a }, { uuid: b }) => a === b;
+    static pathFor(uuid) { return `${this.RemotePath}/${uuid}.wav`; }
+    static async start(cloudHandler, progress, log) {
+        log("Collecting all sample domains...");
+        const [stock, local, cloud] = await Promise.all([
+            OpenSampleAPI.get().all(),
+            SampleStorage.listSamples(),
+            cloudHandler.download(CloudBackupSamples.RemoteCatalogPath)
+                .then(json => JSON.parse(new TextDecoder().decode(json)))
+                .catch(reason => reason instanceof Errors.FileNotFound ? Arrays.empty() : panic(reason))
+        ]);
+        return new CloudBackupSamples(cloudHandler, { stock, local, cloud }, log).#start(progress);
+    }
+    #cloudHandler;
+    #sampleDomains;
+    #log;
+    constructor(cloudHandler, sampleDomains, log) {
+        this.#cloudHandler = cloudHandler;
+        this.#sampleDomains = sampleDomains;
+        this.#log = log;
+    }
+    async #start(progress) {
+        const trashed = await SampleStorage.loadTrashedIds();
+        const [uploadProgress, trashProgress, downloadProgress] = Progress.splitWithWeights(progress, [0.45, 0.10, 0.45]);
+        await this.#upload(uploadProgress);
+        await this.#trash(trashed, trashProgress);
+        await this.#download(trashed, downloadProgress);
+    }
+    async #upload(progress) {
+        const { stock, local, cloud } = this.#sampleDomains;
+        const maybeUnsyncedSamples = Arrays.subtract(local, stock, CloudBackupSamples.areSamplesEqual);
+        const unsyncedSamples = Arrays.subtract(maybeUnsyncedSamples, cloud, CloudBackupSamples.areSamplesEqual);
+        if (unsyncedSamples.length === 0) {
+            this.#log("No unsynced samples found.");
+            progress(1.0);
+            return;
+        }
+        const uploadedSamples = await Promises.sequentialAll(unsyncedSamples.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Uploading sample '${sample.name}'`);
+            const arrayBuffer = await SampleStorage.loadSample(UUID.parse(sample.uuid))
+                .then(([{ frames: channels, numberOfChannels, numberOfFrames: numFrames, sampleRate }]) => WavFile.encodeFloats({ channels, numberOfChannels, numFrames, sampleRate }));
+            const path = CloudBackupSamples.pathFor(sample.uuid);
+            await Promises.approvedRetry(() => this.#cloudHandler.upload(path, arrayBuffer), error => ({
+                headline: "Upload failed",
+                message: `Failed to upload sample '${sample.name}'. '${error}'`,
+                approveText: "Retry",
+                cancelText: "Cancel"
+            }));
+            return sample;
+        }));
+        const catalog = Arrays.merge(cloud, uploadedSamples, CloudBackupSamples.areSamplesEqual);
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #trash(trashed, progress) {
+        const { cloud } = this.#sampleDomains;
+        const obsolete = Arrays.intersect(cloud, trashed, (sample, uuid) => sample.uuid === uuid);
+        if (obsolete.length === 0) {
+            progress(1.0);
+            return;
+        }
+        const approved = await RuntimeNotifier.approve({
+            headline: "Delete Samples?",
+            message: `Found ${obsolete.length} locally deleted samples. Delete from cloud as well?`,
+            approveText: "Yes",
+            cancelText: "No"
+        });
+        if (!approved) {
+            progress(1.0);
+            return;
+        }
+        const result = await Promises.sequentialAll(obsolete.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Deleting '${sample.name}'`);
+            await this.#cloudHandler.delete(CloudBackupSamples.pathFor(sample.uuid));
+            return sample;
+        }));
+        const catalog = cloud.slice();
+        result.forEach((sample) => Arrays.removeIf(catalog, ({ uuid }) => sample.uuid === uuid));
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #download(trashed, progress) {
+        const { cloud, local } = this.#sampleDomains;
+        const missingLocally = Arrays.subtract(cloud, local, CloudBackupSamples.areSamplesEqual);
+        const download = Arrays.subtract(missingLocally, trashed, (sample, uuid) => sample.uuid === uuid);
+        if (download.length === 0) {
+            this.#log("No samples to download.");
+            progress(1.0);
+            return;
+        }
+        await Promises.sequentialAll(download.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Downloading sample '${sample.name}'`);
+            const path = CloudBackupSamples.pathFor(sample.uuid);
+            const buffer = await Promises.guardedRetry(() => this.#cloudHandler.download(path), network.DefaultRetry);
+            const waveAudio = WavFile.decodeFloats(buffer);
+            const audioData = {
+                sampleRate: waveAudio.sampleRate,
+                numberOfFrames: waveAudio.numFrames,
+                numberOfChannels: waveAudio.channels.length,
+                frames: waveAudio.channels
+            };
+            const shifts = SamplePeaks.findBestFit(audioData.numberOfFrames);
+            const peaks = await WorkerAgents.Peak.generateAsync(Progress.Empty, shifts, audioData.frames, audioData.numberOfFrames, audioData.numberOfChannels);
+            await SampleStorage.saveSample(UUID.parse(sample.uuid), audioData, peaks, sample);
+            return sample;
+        }));
+        this.#log("Download samples complete.");
+        progress(1.0);
+    }
+    async #uploadCatalog(catalog) {
+        this.#log("Uploading sample catalog...");
+        const jsonString = JSON.stringify(catalog, null, 2);
+        const buffer = new TextEncoder().encode(jsonString).buffer;
+        return this.#cloudHandler.upload(CloudBackupSamples.RemoteCatalogPath, buffer);
+    }
+}

package/dist/clouds/CloudHandler.d.ts

@@ -0,0 +1,9 @@
+export interface CloudHandler {
+    upload(path: string, data: ArrayBuffer): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    download(path: string): Promise<ArrayBuffer>;
+    list(path?: string): Promise<string[]>;
+    delete(path: string): Promise<void>;
+    alive(): Promise<void>;
+}
+//# sourceMappingURL=CloudHandler.d.ts.map

package/dist/clouds/CloudHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudHandler.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudHandler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAC5C,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACtC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB"}

package/dist/clouds/CloudHandler.js

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

package/dist/clouds/CloudService.d.ts

@@ -0,0 +1,2 @@
+export type CloudService = "Dropbox" | "GoogleDrive";
+//# sourceMappingURL=CloudService.d.ts.map

package/dist/clouds/CloudService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudService.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudService.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA"}

package/dist/clouds/CloudService.js

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

package/dist/clouds/DropboxHandler.d.ts

@@ -0,0 +1,12 @@
+import { CloudHandler } from "./CloudHandler";
+export declare class DropboxHandler implements CloudHandler {
+    #private;
+    constructor(accessToken: string);
+    alive(): Promise<void>;
+    upload(path: string, buffer: ArrayBuffer): Promise<void>;
+    download(path: string): Promise<ArrayBuffer>;
+    exists(path: string): Promise<boolean>;
+    list(path?: string): Promise<Array<string>>;
+    delete(path: string): Promise<void>;
+}
+//# sourceMappingURL=DropboxHandler.d.ts.map

package/dist/clouds/DropboxHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DropboxHandler.d.ts","sourceRoot":"","sources":["../../src/clouds/DropboxHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAI3C,qBAAa,cAAe,YAAW,YAAY;;gBAKnC,WAAW,EAAE,MAAM;IAEzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAe5C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWtC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAO3C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4B5C"}