monoidentity 0.20.0 → 0.21.0

package/dist/Monoidentity.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { Snippet } from "svelte";
+  import { onDestroy, type Snippet } from "svelte";
   import { readyUp } from "./readyup.js";
   import type { Intent } from "./utils-transport.js";
   import type { SyncStrategy } from "./storage/utils-storage.js";
@@ -16,11 +16,17 @@
     children: Snippet;
   } = $props();
 
+  const aborter = new AbortController();
+  onDestroy(() => {
+    aborter.abort();
+  });
+
   let backup: (() => void) | undefined = $state();
   readyUp(
     app,
     intents || [],
     getSyncStrategy,
+    aborter.signal,
     (startBackup) =>
       (backup = () => {
         startBackup();

package/dist/Monoidentity.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { Snippet } from "svelte";
+import { type Snippet } from "svelte";
 import type { Intent } from "./utils-transport.js";
 import type { SyncStrategy } from "./storage/utils-storage.js";
 type $$ComponentProps = {

package/dist/readyup.d.ts

@@ -1,3 +1,3 @@
 import { type Intent } from "./utils-transport.js";
 import type { SyncStrategy } from "./storage/utils-storage.js";
-export declare const readyUp: (app: string, intents: Intent[], getSyncStrategy: (path: string) => SyncStrategy, requestBackup: (startBackup: () => void) => void) => void;
+export declare const readyUp: (app: string, intents: Intent[], getSyncStrategy: (path: string) => SyncStrategy, signal: AbortSignal, requestBackup: (startBackup: () => void) => void) => void;

package/dist/readyup.js

@@ -3,10 +3,13 @@ import {} from "./utils-transport.js";
 // import { wrapBackup } from "./storage/wrapbackup.js";
 // import { wrapCloud } from "./storage/wrapcloud.js";
 import { conf, setLoginRecognized } from "./storage.js";
-import { backupLocally } from "./storage/backuplocally.js";
-import { backupCloud } from "./storage/backupcloud.js";
+import { pullFromLocalBackup } from "./storage/backuplocally-pull.js";
+import { mountLocalBackupPush } from "./storage/backuplocally-push.js";
+import { createCloudClient } from "./storage/backupcloud-shared.js";
+import { mountCloudPull, pullFromCloud } from "./storage/backupcloud-pull.js";
+import { mountCloudPush } from "./storage/backupcloud-push.js";
 import { switchToHub } from "./utils-hub.js";
-export const readyUp = (app, intents, getSyncStrategy, requestBackup) => {
+export const readyUp = (app, intents, getSyncStrategy, signal, requestBackup) => {
     conf(app);
     let setup = localStorage["monoidentity-x/setup"]
         ? JSON.parse(localStorage["monoidentity-x/setup"])
@@ -34,9 +37,27 @@ export const readyUp = (app, intents, getSyncStrategy, requestBackup) => {
     }
     // fire off backup
     if (setup.method == "localStorage") {
-        backupLocally(getSyncStrategy, requestBackup);
+        void pullFromLocalBackup(requestBackup)
+            .then((dir) => {
+            signal.throwIfAborted();
+            if (!dir)
+                return;
+            mountLocalBackupPush(getSyncStrategy, dir, signal);
+        })
+            .catch((err) => {
+            console.error("[monoidentity local] pull failed", err);
+        });
     }
     if (setup.method == "cloud") {
-        backupCloud(getSyncStrategy, setup);
+        const client = createCloudClient(setup);
+        void pullFromCloud(getSyncStrategy, setup, client)
+            .then(() => {
+            signal.throwIfAborted();
+            mountCloudPull(getSyncStrategy, setup, client, signal);
+            mountCloudPush(getSyncStrategy, setup, client, signal);
+        })
+            .catch((err) => {
+            console.error("[monoidentity cloud] pull failed", err);
+        });
     }
 };

package/dist/storage/backupcloud-pull.d.ts

@@ -0,0 +1,6 @@
+import type { Bucket } from "../utils-transport.js";
+import { type SyncStrategy } from "./utils-storage.js";
+export type AwsFetch = (url: string, options?: RequestInit) => Promise<Response>;
+export declare const setCloudCacheEntry: (key: string, etag: string, content: string) => Promise<void>;
+export declare const pullFromCloud: (getSyncStrategy: (path: string) => SyncStrategy, bucket: Bucket, client: AwsFetch) => Promise<void>;
+export declare const mountCloudPull: (getSyncStrategy: (path: string) => SyncStrategy, bucket: Bucket, client: AwsFetch, signal: AbortSignal) => () => void;

package/dist/storage/backupcloud-pull.js

@@ -0,0 +1,102 @@
+import { storageClient } from "./storageclient.svelte.js";
+import { addSync } from "./utils-sync.js";
+import { shouldPersist } from "./utils-storage.js";
+import { get, set } from "idb-keyval";
+import { store } from "./utils-idb.js";
+const CLOUD_CACHE_KEY = "cloud-cache";
+let cache;
+const initCache = async () => {
+    cache = (await get(CLOUD_CACHE_KEY, store)) || {};
+};
+const getCache = () => {
+    if (!cache)
+        throw new Error("Cache not initialized");
+    return cache;
+};
+const saveCache = async () => {
+    await set(CLOUD_CACHE_KEY, getCache(), store);
+};
+export const setCloudCacheEntry = async (key, etag, content) => {
+    await initCache();
+    getCache()[key] = { etag, content };
+    await saveCache();
+};
+const loadFromCloud = async (getSyncStrategy, base, client) => {
+    const cacheInit = initCache();
+    const listResp = await client(base);
+    if (!listResp.ok)
+        throw new Error(`List bucket failed: ${listResp.status}`);
+    const listXml = await listResp.text();
+    const objects = [...listXml.matchAll(/<Key>(.*?)<\/Key>.*?<ETag>(.*?)<\/ETag>/gs)]
+        .map((m) => m.slice(1).map((s) => s.replaceAll("&quot;", `"`).replaceAll("&apos;", `'`)))
+        .map(([key, etag]) => ({ key, etag: etag.replaceAll(`"`, "") }))
+        .filter(({ key }) => getSyncStrategy(key));
+    await cacheInit;
+    const prevCache = getCache();
+    const nextCache = {};
+    const model = {};
+    await Promise.all(objects.map(async ({ key, etag }) => {
+        const cached = prevCache[key];
+        if (cached?.etag == etag) {
+            model[key] = cached.content;
+            nextCache[key] = cached;
+            return;
+        }
+        console.debug("[monoidentity cloud] loading", key);
+        const r = await client(`${base}/${key}`);
+        if (!r.ok)
+            throw new Error(`Fetch ${key} failed: ${r.status}`);
+        let content;
+        if (key.endsWith(".md") || key.endsWith(".devalue")) {
+            content = await r.text();
+        }
+        else {
+            const buf = new Uint8Array(await r.arrayBuffer());
+            content = "";
+            const chunk = 8192;
+            for (let i = 0; i < buf.length; i += chunk) {
+                content += String.fromCharCode.apply(null, buf.subarray(i, i + chunk));
+            }
+        }
+        model[key] = content;
+        nextCache[key] = { etag, content };
+    }));
+    cache = nextCache;
+    await saveCache();
+    return model;
+};
+const _pullFromCloud = async (getSyncStrategy, bucket, client) => {
+    const remote = await loadFromCloud(getSyncStrategy, bucket.base, client);
+    const local = storageClient();
+    for (const key of Object.keys(local)) {
+        if (key in remote)
+            continue;
+        if (shouldPersist(key))
+            continue;
+        delete local[key];
+    }
+    for (const [key, value] of Object.entries(remote)) {
+        if (local[key] == value)
+            continue;
+        local[key] = value;
+    }
+};
+export const pullFromCloud = async (getSyncStrategy, bucket, client) => {
+    const promise = _pullFromCloud(getSyncStrategy, bucket, client);
+    addSync("*", promise);
+    await promise;
+};
+export const mountCloudPull = (getSyncStrategy, bucket, client, signal) => {
+    signal.throwIfAborted();
+    const syncIntervalId = setInterval(() => {
+        pullFromCloud(getSyncStrategy, bucket, client).catch((err) => {
+            console.error("[monoidentity cloud] pull failed", err);
+        });
+    }, 15 * 60 * 1000);
+    const cleanup = () => {
+        clearInterval(syncIntervalId);
+        signal.removeEventListener("abort", cleanup);
+    };
+    signal.addEventListener("abort", cleanup, { once: true });
+    return cleanup;
+};

package/dist/storage/backupcloud-push.d.ts

@@ -0,0 +1,4 @@
+import type { Bucket } from "../utils-transport.js";
+import { type SyncStrategy } from "./utils-storage.js";
+import { type AwsFetch } from "./backupcloud-pull.js";
+export declare const mountCloudPush: (getSyncStrategy: (path: string) => SyncStrategy, bucket: Bucket, client: AwsFetch, signal: AbortSignal) => () => void;

package/dist/storage/backupcloud-push.js

@@ -0,0 +1,56 @@
+import { STORAGE_EVENT } from "./storageclient.svelte.js";
+import { addSync, scheduleSync } from "./utils-sync.js";
+import { shouldPersist } from "./utils-storage.js";
+import { setCloudCacheEntry } from "./backupcloud-pull.js";
+const write = async (key, value, bucket, client) => {
+    console.debug("[monoidentity cloud] saving", key);
+    const url = `${bucket.base}/${key}`;
+    if (value != undefined) {
+        const r = await client(url, {
+            method: "PUT",
+            headers: { "content-type": "application/octet-stream" },
+            body: value,
+        });
+        if (!r.ok)
+            throw new Error(`PUT ${key} failed: ${r.status}`);
+        const etag = r.headers.get("etag")?.replaceAll('"', "");
+        if (etag) {
+            await setCloudCacheEntry(key, etag, value);
+        }
+        return;
+    }
+    const r = await client(url, { method: "DELETE" });
+    if (!r.ok && r.status != 404)
+        throw new Error(`DELETE ${key} failed: ${r.status}`);
+};
+export const mountCloudPush = (getSyncStrategy, bucket, client, signal) => {
+    signal.throwIfAborted();
+    const writeWrapped = async (key, value) => write(key, value, bucket, client).catch((err) => {
+        console.error("[monoidentity cloud] save failed", key, err);
+    });
+    const listener = (event) => {
+        const fullKey = event.detail.key;
+        if (!fullKey.startsWith("monoidentity/"))
+            return;
+        const key = fullKey.slice("monoidentity/".length);
+        const strategy = getSyncStrategy(key);
+        if (!strategy) {
+            if (!shouldPersist(key))
+                console.warn("[monoidentity cloud]", key, "isn't marked to be synced");
+            return;
+        }
+        if (strategy.mode == "immediate") {
+            addSync(fullKey, writeWrapped(key, event.detail.value));
+        }
+        else if (strategy.mode == "debounced") {
+            scheduleSync(fullKey, () => writeWrapped(key, localStorage[fullKey]), strategy.debounceMs);
+        }
+    };
+    addEventListener(STORAGE_EVENT, listener);
+    const cleanup = () => {
+        removeEventListener(STORAGE_EVENT, listener);
+        signal.removeEventListener("abort", cleanup);
+    };
+    signal.addEventListener("abort", cleanup, { once: true });
+    return cleanup;
+};

package/dist/storage/backupcloud-shared.d.ts

@@ -0,0 +1,3 @@
+import type { Bucket } from "../utils-transport.js";
+import type { AwsFetch } from "./backupcloud-pull.js";
+export declare const createCloudClient: (bucket: Bucket) => AwsFetch;

package/dist/storage/backupcloud-shared.js

@@ -0,0 +1,8 @@
+import { AwsClient } from "aws4fetch";
+export const createCloudClient = (bucket) => {
+    const awsClient = new AwsClient({
+        accessKeyId: bucket.accessKeyId,
+        secretAccessKey: bucket.secretAccessKey,
+    });
+    return (url, options) => awsClient.fetch(url, { ...options, aws: { signQuery: true } });
+};

package/dist/storage/backuplocally-pull.d.ts

@@ -0,0 +1 @@
+export declare const pullFromLocalBackup: (requestBackup: (startBackup: () => void) => void) => Promise<FileSystemDirectoryHandle | undefined>;

package/dist/storage/backuplocally-pull.js

@@ -0,0 +1,58 @@
+import { get, set } from "idb-keyval";
+import { canBackup } from "../utils-localstorage.js";
+import { storageClient } from "./storageclient.svelte.js";
+import { store } from "./utils-idb.js";
+import { addSync } from "./utils-sync.js";
+const HANDLE_KEY = "backup-handle";
+const HANDLE_DISABLED_KEY = "backup-handle-disabled";
+const restoreFromDir = async (dir) => {
+    const backup = {};
+    const traverse = async (d, path) => {
+        for await (const entry of d.values()) {
+            if (entry.kind == "file") {
+                const file = await entry.getFile();
+                const text = await file.text();
+                backup[`${path}${entry.name}`] = text;
+            }
+            else if (entry.kind == "directory") {
+                await traverse(entry, `${path}${entry.name}/`);
+            }
+        }
+    };
+    await traverse(dir, "");
+    if (!Object.keys(backup).length)
+        return;
+    const client = storageClient();
+    for (const key in backup) {
+        console.debug("[monoidentity local] loading", key);
+        client[key] = backup[key];
+    }
+    location.reload();
+};
+export const pullFromLocalBackup = async (requestBackup) => {
+    if (!canBackup)
+        return;
+    const dir = await get(HANDLE_KEY, store);
+    if (dir) {
+        return dir;
+    }
+    const disabled = await get(HANDLE_DISABLED_KEY, store);
+    if (disabled) {
+        return;
+    }
+    await set(HANDLE_DISABLED_KEY, true);
+    return new Promise((resolve, reject) => requestBackup(async () => {
+        try {
+            const dir = await showDirectoryPicker({ mode: "readwrite" });
+            await set(HANDLE_KEY, dir, store);
+            await set(HANDLE_DISABLED_KEY, false);
+            const restorePromise = restoreFromDir(dir);
+            addSync("*", restorePromise);
+            await restorePromise;
+            resolve(dir);
+        }
+        catch (error) {
+            reject(error);
+        }
+    }));
+};

package/dist/storage/backuplocally-push.d.ts

@@ -0,0 +1,2 @@
+import { type SyncStrategy } from "./utils-storage.js";
+export declare const mountLocalBackupPush: (getSyncStrategy: (path: string) => SyncStrategy, dir: FileSystemDirectoryHandle, signal: AbortSignal) => () => void;

package/dist/storage/backuplocally-push.js

@@ -0,0 +1,63 @@
+import { STORAGE_EVENT } from "./storageclient.svelte.js";
+import { shouldPersist } from "./utils-storage.js";
+import { addSync } from "./utils-sync.js";
+const saveToDir = (getSyncStrategy, dir) => {
+    let dirCache = {};
+    const getDirCached = async (route) => {
+        let key = "";
+        let parent = dir;
+        for (const path of route) {
+            key += "/";
+            key += path;
+            if (!dirCache[key]) {
+                dirCache[key] = await parent.getDirectoryHandle(path, { create: true });
+            }
+            parent = dirCache[key];
+        }
+        return parent;
+    };
+    const writeFile = async (key, value) => {
+        const pathParts = key.split("/");
+        const name = pathParts.at(-1);
+        console.debug("[monoidentity local] saving", name);
+        const parent = await getDirCached(pathParts.slice(0, -1));
+        if (value != undefined) {
+            const file = await parent.getFileHandle(name, { create: true });
+            const writable = await file.createWritable();
+            await writable.write(value);
+            await writable.close();
+            return;
+        }
+        await parent.removeEntry(name);
+    };
+    const listener = (event) => {
+        const fullKey = event.detail.key;
+        if (!fullKey.startsWith("monoidentity/"))
+            return;
+        const key = fullKey.slice("monoidentity/".length);
+        const strategy = getSyncStrategy(key);
+        if (!strategy) {
+            if (!shouldPersist(key))
+                console.warn("[monoidentity local]", key, "isn't marked to be backed up or saved");
+            return;
+        }
+        addSync(key, writeFile(key, event.detail.value));
+    };
+    addEventListener(STORAGE_EVENT, listener);
+    return () => {
+        removeEventListener(STORAGE_EVENT, listener);
+    };
+};
+export const mountLocalBackupPush = (getSyncStrategy, dir, signal) => {
+    signal.throwIfAborted();
+    const unmount = saveToDir(getSyncStrategy, dir);
+    const cleanup = () => {
+        unmount();
+        signal.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+        cleanup();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    return cleanup;
+};

package/dist/storage/utils-sync.js

@@ -11,7 +11,9 @@ const runScheduledSync = async (key) => {
     if (!scheduled)
         return;
     delete scheduledSyncs[key];
-    addSync(key, scheduled.fn());
+    const promise = scheduled.fn();
+    addSync(key, promise);
+    await promise;
 };
 const scheduleInterval = setInterval(() => {
     const now = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "license": "ISC",
   "repository": "KTibow/monoidentity",
   "author": {

package/dist/storage/backupcloud.d.ts

@@ -1,3 +0,0 @@
-import type { Bucket } from "../utils-transport.js";
-import { type SyncStrategy } from "./utils-storage.js";
-export declare const backupCloud: (getSyncStrategy: (path: string) => SyncStrategy, bucket: Bucket) => Promise<void>;

package/dist/storage/backupcloud.js

@@ -1,154 +0,0 @@
-import { AwsClient } from "aws4fetch";
-import { storageClient, STORAGE_EVENT } from "./storageclient.svelte.js";
-import { addSync, scheduleSync } from "./utils-sync.js";
-import { shouldPersist } from "./utils-storage.js";
-import { get, set } from "idb-keyval";
-import { store } from "./utils-idb.js";
-const CLOUD_CACHE_KEY = "cloud-cache";
-let unmount;
-let cache;
-const initCache = async () => {
-    cache = (await get(CLOUD_CACHE_KEY, store)) || {};
-};
-const getCache = () => {
-    if (!cache)
-        throw new Error("Cache not initialized");
-    return cache;
-};
-const saveCache = async () => {
-    if (!cache)
-        throw new Error("Cache not initialized");
-    await set(CLOUD_CACHE_KEY, cache, store);
-};
-const loadFromCloud = async (getSyncStrategy, base, client) => {
-    const cachePromise = initCache();
-    const listResp = await client.fetch(base);
-    if (!listResp.ok)
-        throw new Error(`List bucket failed: ${listResp.status}`);
-    const listXml = await listResp.text();
-    const objects = [...listXml.matchAll(/<Key>(.*?)<\/Key>.*?<ETag>(.*?)<\/ETag>/gs)]
-        .map((m) => m.slice(1).map((s) => s.replaceAll("&quot;", `"`).replaceAll("&apos;", `'`)))
-        .map(([key, etag]) => ({ key, etag: etag.replaceAll(`"`, "") }))
-        .filter(({ key }) => getSyncStrategy(key));
-    await cachePromise;
-    const prevCache = getCache();
-    const nextCache = {};
-    const model = {};
-    await Promise.all(objects.map(async ({ key, etag }) => {
-        const cached = prevCache[key];
-        if (cached?.etag == etag) {
-            model[key] = cached.content;
-            nextCache[key] = cached;
-            return;
-        }
-        console.debug("[monoidentity cloud] loading", key);
-        const r = await client.fetch(`${base}/${key}`);
-        if (!r.ok)
-            throw new Error(`Fetch ${key} failed: ${r.status}`);
-        let content;
-        if (key.endsWith(".md") || key.endsWith(".devalue")) {
-            content = await r.text();
-        }
-        else {
-            const buf = new Uint8Array(await r.arrayBuffer());
-            content = "";
-            const chunk = 8192;
-            for (let i = 0; i < buf.length; i += chunk) {
-                content += String.fromCharCode.apply(null, buf.subarray(i, i + chunk));
-            }
-        }
-        model[key] = content;
-        nextCache[key] = { etag, content };
-    }));
-    cache = nextCache;
-    saveCache();
-    return model;
-};
-const _syncFromCloud = async (getSyncStrategy, bucket, client) => {
-    const remote = await loadFromCloud(getSyncStrategy, bucket.base, client);
-    const local = storageClient();
-    for (const key of Object.keys(local)) {
-        if (key in remote)
-            continue;
-        if (shouldPersist(key))
-            continue;
-        delete local[key];
-    }
-    for (const [key, value] of Object.entries(remote)) {
-        if (local[key] == value)
-            continue;
-        local[key] = value;
-    }
-};
-const syncFromCloud = async (getSyncStrategy, bucket, client) => {
-    const promise = _syncFromCloud(getSyncStrategy, bucket, client);
-    addSync("*", promise);
-    await promise;
-};
-export const backupCloud = async (getSyncStrategy, bucket) => {
-    unmount?.();
-    const client = new AwsClient({
-        accessKeyId: bucket.accessKeyId,
-        secretAccessKey: bucket.secretAccessKey,
-    });
-    await syncFromCloud(getSyncStrategy, bucket, client);
-    const syncIntervalId = setInterval(() => syncFromCloud(getSyncStrategy, bucket, client), 15 * 60 * 1000);
-    // Continuous sync: mirror local changes to cloud
-    const write = async (key, value) => {
-        console.debug("[monoidentity cloud] saving", key);
-        const url = `${bucket.base}/${key}`;
-        if (value != undefined) {
-            // PUT content (unconditional to start; you can add If-Match/If-None-Match for safety)
-            const r = await client.fetch(url, {
-                method: "PUT",
-                headers: { "content-type": "application/octet-stream" },
-                body: value,
-            });
-            if (!r.ok)
-                throw new Error(`PUT ${key} failed: ${r.status}`);
-            // Update cache
-            const etag = r.headers.get("etag")?.replaceAll('"', "");
-            if (etag) {
-                getCache()[key] = { etag, content: value };
-                saveCache();
-            }
-        }
-        else {
-            // DELETE key
-            const r = await client.fetch(url, { method: "DELETE" });
-            if (!r.ok && r.status != 404)
-                throw new Error(`DELETE ${key} failed: ${r.status}`);
-        }
-    };
-    const writeWrapped = async (key, value) => write(key, value).catch((err) => {
-        console.error("[monoidentity cloud] save failed", key, err);
-    });
-    const listener = (event) => {
-        const fullKey = event.detail.key;
-        if (!fullKey.startsWith("monoidentity/"))
-            return;
-        const key = fullKey.slice("monoidentity/".length);
-        const strategy = getSyncStrategy(key);
-        if (!strategy) {
-            if (!shouldPersist(key))
-                console.warn("[monoidentity cloud]", key, "isn't marked to be backed up or saved");
-            return;
-        }
-        if (strategy.mode == "immediate") {
-            addSync(fullKey, writeWrapped(key, event.detail.value));
-        }
-        else if (strategy.mode == "debounced") {
-            scheduleSync(fullKey, () => writeWrapped(key, localStorage[fullKey]), strategy.debounceMs);
-        }
-    };
-    addEventListener(STORAGE_EVENT, listener);
-    unmount = () => {
-        clearInterval(syncIntervalId);
-        removeEventListener(STORAGE_EVENT, listener);
-    };
-};
-if (import.meta.hot) {
-    import.meta.hot.dispose(() => {
-        unmount?.();
-    });
-}

package/dist/storage/backuplocally.d.ts

@@ -1,2 +0,0 @@
-import { type SyncStrategy } from "./utils-storage.js";
-export declare const backupLocally: (getSyncStrategy: (path: string) => SyncStrategy, requestBackup: (startBackup: () => void) => void) => Promise<void>;

package/dist/storage/backuplocally.js

@@ -1,112 +0,0 @@
-import { get, set } from "idb-keyval";
-import { STORAGE_EVENT, storageClient } from "./storageclient.svelte.js";
-import { canBackup } from "../utils-localstorage.js";
-import { shouldPersist } from "./utils-storage.js";
-import { store } from "./utils-idb.js";
-import { addSync } from "./utils-sync.js";
-const TOGGLE_KEY = "monoidentity-x/local-backup";
-const HANDLE_KEY = "backup-handle";
-let unmount;
-const saveToDir = (getSyncStrategy, dir) => {
-    let dirCache = {};
-    const getDirCached = async (route) => {
-        let key = "";
-        let parent = dir;
-        for (const path of route) {
-            key += "/";
-            key += path;
-            if (!dirCache[key]) {
-                dirCache[key] = await parent.getDirectoryHandle(path, { create: true });
-            }
-            parent = dirCache[key];
-        }
-        return parent;
-    };
-    const writeFile = async (key, value) => {
-        const pathParts = key.split("/");
-        const name = pathParts.at(-1);
-        console.debug("[monoidentity backup] saving", name);
-        const parent = await getDirCached(pathParts.slice(0, -1));
-        if (value != undefined) {
-            const file = await parent.getFileHandle(name, { create: true });
-            const writable = await file.createWritable();
-            await writable.write(value);
-            await writable.close();
-        }
-        else {
-            await parent.removeEntry(name);
-        }
-    };
-    const listener = (event) => {
-        const fullKey = event.detail.key;
-        if (!fullKey.startsWith("monoidentity/"))
-            return;
-        const key = fullKey.slice("monoidentity/".length);
-        const strategy = getSyncStrategy(key);
-        if (!strategy) {
-            if (!shouldPersist(key))
-                console.warn("[monoidentity backup]", key, "isn't marked to be backed up or saved");
-            return;
-        }
-        addSync(key, writeFile(key, event.detail.value));
-    };
-    addEventListener(STORAGE_EVENT, listener);
-    return () => {
-        removeEventListener(STORAGE_EVENT, listener);
-    };
-};
-export const backupLocally = async (getSyncStrategy, requestBackup) => {
-    if (!canBackup)
-        return;
-    if (localStorage[TOGGLE_KEY] == "off")
-        return;
-    unmount?.();
-    if (localStorage[TOGGLE_KEY] == "on") {
-        const dir = await get(HANDLE_KEY, store);
-        if (!dir)
-            throw new Error("No backup handle found");
-        unmount = saveToDir(getSyncStrategy, dir);
-    }
-    else {
-        localStorage[TOGGLE_KEY] = "off";
-        requestBackup(async () => {
-            const dir = await showDirectoryPicker({ mode: "readwrite" });
-            await set(HANDLE_KEY, dir, store);
-            localStorage[TOGGLE_KEY] = "on";
-            // Restore from backup
-            const restorePromise = (async () => {
-                const backup = {};
-                const traverse = async (d, path) => {
-                    for await (const entry of d.values()) {
-                        if (entry.kind == "file") {
-                            const file = await entry.getFile();
-                            const text = await file.text();
-                            backup[`${path}${entry.name}`] = text;
-                        }
-                        else if (entry.kind == "directory") {
-                            await traverse(entry, `${path}${entry.name}/`);
-                        }
-                    }
-                };
-                await traverse(dir, "");
-                if (Object.keys(backup).length) {
-                    const client = storageClient();
-                    for (const key in backup) {
-                        console.debug("[monoidentity backup] loading", key);
-                        client[key] = backup[key];
-                    }
-                    location.reload();
-                    return;
-                }
-            })();
-            addSync("*", restorePromise);
-            await restorePromise;
-            unmount = saveToDir(getSyncStrategy, dir);
-        });
-    }
-};
-if (import.meta.hot) {
-    import.meta.hot.dispose(() => {
-        unmount?.();
-    });
-}