monoidentity 0.30.1 → 0.31.1

package/dist/{storage.d.ts → +index.d.ts}

@@ -4,6 +4,6 @@ export declare const getLoginRecognized: () => {
 };
 export declare const setLoginRecognized: (login: string) => void;
 export declare const openHub: (path: string) => never;
-export declare const VERIFICATION_PATH = ".local/verification.jwt";
+export declare const relog: () => never;
 export declare const getStorage: (realm: "config" | "userdata" | "cache" | (string & {})) => Record<string, any>;
 export declare const getScopedFS: (dir: string) => Record<string, any>;

package/dist/{storage.js → +index.js}

@@ -1,8 +1,9 @@
 import { stringify, parse } from 'devalue';
 import { parse as useSchema } from 'valibot';
-import { decode } from './utils-base36.js';
-import { login as loginSchema } from './utils-transport.js';
+import { decode } from 'base36-esm';
 import { storageClient } from './storageclient.svelte.js';
+import { object, pipe, email, string } from 'valibot';
+const loginSchema = object({ email: pipe(string(), email()), password: string() });
 const LOGIN_RECOGNIZED_PATH = '.local/login.encjson';
 export const getLoginRecognized = () => {
     const client = storageClient();
@@ -30,7 +31,7 @@ export const openHub = (path) => {
     location.href = target.toString();
     throw new Error('relogging');
 };
-export const VERIFICATION_PATH = '.local/verification.jwt';
+export const relog = () => openHub(MONOIDENTITY_APP_ID);
 export const getStorage = (realm) => {
     const prefix = `.${realm}/${MONOIDENTITY_APP_ID}/`;
     return storageClient((key) => `${prefix}${key}.devalue`, (key) => (key.startsWith(prefix) ? key.slice(prefix.length, -'.devalue'.length) : undefined), stringify, parse);

package/dist/+receive-callback.js

@@ -1,4 +1,4 @@
-import { setLoginRecognized } from './storage.js';
+import { setLoginRecognized } from './+index.js';
 const params = new URLSearchParams(location.hash.slice(1));
 const monoidentityloginrecognized = params.get('monoidentityloginrecognized');
 if (monoidentityloginrecognized) {

package/dist/+types.d.ts

@@ -0,0 +1 @@
+declare const MONOIDENTITY_APP_ID: string;

package/dist/storageclient.svelte.d.ts

@@ -1,11 +1,9 @@
-export declare const waitForSync: (key: string) => Promise<void>;
 declare global {
     interface WindowEventMap {
-        "monoidentity-storage": CustomEvent<{
+        'monoidentity-storage': CustomEvent<{
             key: string;
             value: string | undefined;
         }>;
     }
 }
-export declare const STORAGE_EVENT = "monoidentity-storage";
 export declare const storageClient: (prefix?: (key: string) => string, unprefix?: (key: string) => string | undefined, serialize?: (data: any) => string, deserialize?: (data: string) => any) => Record<string, any>;

package/dist/storageclient.svelte.js

@@ -1,8 +1,8 @@
-import { SYNC_REQUEST_EVENT } from "./old/storage/utils-sync.js";
-export const waitForSync = async (key) => {
+const SYNC_REQUEST_EVENT = 'monoidentity-sync-request';
+const STORAGE_EVENT = 'monoidentity-storage';
+const waitForSync = async (key) => {
     await new Promise((resolve, reject) => window.dispatchEvent(new CustomEvent(SYNC_REQUEST_EVENT, { detail: { key, resolve, reject } })));
 };
-export const STORAGE_EVENT = "monoidentity-storage";
 const announce = (key, value) => {
     // Announce to all, even third parties
     window.dispatchEvent(new CustomEvent(STORAGE_EVENT, { detail: { key, value } }));
@@ -14,7 +14,7 @@ const increment = (key) => {
     allCounter++;
 };
 addEventListener(STORAGE_EVENT, (event) => increment(event.detail.key));
-addEventListener("storage", (event) => {
+addEventListener('storage', (event) => {
     if (event.storageArea != localStorage)
         return;
     if (!event.key)
@@ -32,9 +32,9 @@ export const storageClient = (prefix, unprefix, serialize, deserialize) => {
     const getScopedKeys = () => {
         const keys = [];
         for (const key in localStorage) {
-            if (!key.startsWith("monoidentity/"))
+            if (!key.startsWith('monoidentity/'))
                 continue;
-            let scopedKey = key.slice("monoidentity/".length);
+            let scopedKey = key.slice('monoidentity/'.length);
             if (unprefix) {
                 const unprefixed = unprefix(scopedKey);
                 if (!unprefixed)
@@ -47,9 +47,9 @@ export const storageClient = (prefix, unprefix, serialize, deserialize) => {
     };
     return new Proxy({}, {
         get(_, key) {
-            if (typeof key == "symbol")
+            if (typeof key == 'symbol')
                 return undefined;
-            if (key == "sync") {
+            if (key == 'sync') {
                 return async (userKey) => {
                     await waitForSync(prefix(userKey));
                 };
@@ -68,7 +68,7 @@ export const storageClient = (prefix, unprefix, serialize, deserialize) => {
                 announce(key, value);
             }
             else {
-                console.debug("[monoidentity storage] noop for", key);
+                console.debug('[monoidentity storage] noop for', key);
             }
             return true;
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monoidentity",
-  "version": "0.30.1",
+  "version": "0.31.1",
   "license": "ISC",
   "repository": "KTibow/monoidentity",
   "author": {
@@ -20,8 +20,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/+client.d.ts",
-      "svelte": "./dist/+client.js"
+      "types": "./dist/+index.d.ts",
+      "svelte": "./dist/+index.js"
     },
     "./receive-callback": {
       "types": "./dist/+receive-callback.d.ts",
@@ -32,9 +32,8 @@
     "svelte": "^5.0.0"
   },
   "dependencies": {
-    "aws4fetch": "^1.0.20",
+    "base36-esm": "^0.1.0",
     "devalue": "^5.6.2",
-    "idb-keyval": "^6.2.2",
     "valibot": "^1.2.0"
   },
   "devDependencies": {
@@ -42,13 +41,9 @@
     "@sveltejs/kit": "^2.51.0",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
-    "@types/wicg-file-system-access": "^2023.10.7",
-    "monoserve": "^3.2.4",
     "publint": "^0.3.17",
-    "rolldown": "1.0.0-rc.4",
     "svelte": "^5.51.0",
     "svelte-check": "^4.4.0",
-    "tinyglobby": "^0.2.15",
     "vite": "8.0.0-beta.15"
   },
   "keywords": [
@@ -58,7 +53,6 @@
     "dev": "vite dev",
     "build": "pnpm run prepack",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-    "knip": "knip"
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch"
   }
 }

package/dist/+client.d.ts

@@ -1,4 +0,0 @@
-export { encode, decode } from './utils-base36.js';
-export { getLoginRecognized, openHub, getStorage, getScopedFS, VERIFICATION_PATH, } from './storage.js';
-export type { SyncStrategy } from './client.js';
-export type { Bucket, StorageSetup } from './utils-transport.js';

package/dist/+client.js

@@ -1,4 +0,0 @@
-// common
-export { encode, decode } from './utils-base36.js';
-// storage
-export { getLoginRecognized, openHub, getStorage, getScopedFS, VERIFICATION_PATH, } from './storage.js';

package/dist/bucket-create.remote.d.ts

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

package/dist/bucket-create.remote.js

@@ -1,126 +0,0 @@
-"use strict";
-// import { fn } from "monoserve";
-// import { string } from "valibot";
-// import { encodeBucket } from "./specific-utils";
-// import { useVerification } from "monoidentity/server";
-// import { CF_ACCOUNT_ID, CF_KEY } from "$env/static/private";
-// const KV_NAMESPACE_ID = "6b33cf77a0bf4a029bc17b738c9f2cdb";
-// async function sha256(text: string): Promise<string> {
-//   const encoder = new TextEncoder();
-//   const data = encoder.encode(text);
-//   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-//   const hashArray = Array.from(new Uint8Array(hashBuffer));
-//   return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-// }
-// export default fn(string(), async (jwt) => {
-//   // Verify JWT and get user email
-//   const { payload } = await useVerification(jwt);
-//   const user = payload.sub!.replace(/[@.]/g, "-");
-//   // Check if credentials already exist in KV
-//   const existingCreds = await fetch(
-//     `https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/storage/kv/namespaces/${KV_NAMESPACE_ID}/values/${user}`,
-//     {
-//       headers: { authorization: `Bearer ${CF_KEY}` },
-//     },
-//   );
-//   if (existingCreds.ok) {
-//     return await existingCreds.text(); // Already encoded
-//   }
-//   // Generate unique bucket name
-//   const bucketName = `monoidentity-cloud-${user}`;
-//   // 1. Create R2 bucket
-//   const bucketRes = await fetch(
-//     `https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/r2/buckets`,
-//     {
-//       method: "POST",
-//       headers: {
-//         authorization: `Bearer ${CF_KEY}`,
-//         "content-type": "application/json",
-//       },
-//       body: JSON.stringify({ name: bucketName }),
-//     },
-//   );
-//   if (!bucketRes.ok) {
-//     throw new Error(`Failed to create bucket: ${await bucketRes.text()}`);
-//   }
-//   // 2. Set CORS policy
-//   const corsConfig = {
-//     rules: [
-//       {
-//         allowed: {
-//           origins: ["*"],
-//           methods: ["GET", "PUT", "POST", "DELETE", "HEAD"],
-//           headers: [
-//             "authorization",
-//             "content-type",
-//             "if-match",
-//             "if-none-match",
-//             "x-amz-date",
-//             "x-amz-content-sha256",
-//           ],
-//         },
-//         exposeHeaders: ["ETag"],
-//         maxAgeSeconds: 3600,
-//       },
-//     ],
-//   };
-//   const corsRes = await fetch(
-//     `https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/r2/buckets/${bucketName}/cors`,
-//     {
-//       method: "PUT",
-//       headers: {
-//         authorization: `Bearer ${CF_KEY}`,
-//         "content-type": "application/json",
-//       },
-//       body: JSON.stringify(corsConfig),
-//     },
-//   );
-//   if (!corsRes.ok) {
-//     throw new Error(`Failed to set CORS: ${await corsRes.text()}`);
-//   }
-//   // 3. Create scoped API token
-//   const tokenRes = await fetch(`https://api.cloudflare.com/client/v4/user/tokens`, {
-//     method: "POST",
-//     headers: {
-//       authorization: `Bearer ${CF_KEY}`,
-//       "content-type": "application/json",
-//     },
-//     body: JSON.stringify({
-//       name: `monoidentity-cloud-token-${user}`,
-//       policies: [
-//         {
-//           effect: "allow",
-//           resources: {
-//             [`com.cloudflare.edge.r2.bucket.${CF_ACCOUNT_ID}_default_${bucketName}`]: "*",
-//           },
-//           permission_groups: [{ id: "2efd5506f9c8494dacb1fa10a3e7d5b6" }], // Workers R2 Storage Bucket Item Write
-//         },
-//       ],
-//     }),
-//   });
-//   if (!tokenRes.ok) {
-//     throw new Error(`Failed to create token: ${await tokenRes.text()}`);
-//   }
-//   const {
-//     result: { id: accessKeyId, value: secretAccessKeyInput },
-//   } = await tokenRes.json();
-//   const secretAccessKey = await sha256(secretAccessKeyInput);
-//   // 4. Encode and store in KV
-//   const encoded = encodeBucket({
-//     base: `https://${CF_ACCOUNT_ID}.r2.cloudflarestorage.com/${bucketName}`,
-//     accessKeyId,
-//     secretAccessKey,
-//   });
-//   const kvRes = await fetch(
-//     `https://api.cloudflare.com/client/v4/accounts/${CF_ACCOUNT_ID}/storage/kv/namespaces/${KV_NAMESPACE_ID}/values/${user}`,
-//     {
-//       method: "PUT",
-//       headers: { authorization: `Bearer ${CF_KEY}` },
-//       body: encoded,
-//     },
-//   );
-//   if (!kvRes.ok) {
-//     throw new Error(`Failed to store credentials in KV: ${await kvRes.text()}`);
-//   }
-//   return encoded;
-// });

package/dist/client.d.ts

@@ -1,8 +0,0 @@
-export type SyncStrategy =
-  | undefined // do not upload or download; will be deleted on next sync unless shouldPersist(key)
-  | { mode: "immediate" } // instant sync (e.g., config)
-  | { mode: "debounced"; debounceMs: number }; // queued sync (e.g., notes, drawings, chats)
-declare global {
-  declare const MONOIDENTITY_APP_ID: string;
-  declare const MONOIDENTITY_SYNC_FOR: (path: string) => SyncStrategy;
-}

package/dist/old/storage/_backupcloud.d.ts

@@ -1,2 +0,0 @@
-export declare const encodeCloudContent: (key: string, value: string) => string | Uint8Array<ArrayBuffer>;
-export declare const decodeCloudContent: (key: string, response: Response) => Promise<string>;

package/dist/old/storage/_backupcloud.js

@@ -1,23 +0,0 @@
-const isPlainTextCloudObject = (key) => key.endsWith(".md") || key.endsWith(".devalue");
-export const encodeCloudContent = (key, value) => {
-    if (isPlainTextCloudObject(key)) {
-        return value;
-    }
-    const bytes = new Uint8Array(value.length);
-    for (let i = 0; i < value.length; i++) {
-        bytes[i] = value.charCodeAt(i);
-    }
-    return bytes;
-};
-export const decodeCloudContent = async (key, response) => {
-    if (isPlainTextCloudObject(key)) {
-        return response.text();
-    }
-    const buf = new Uint8Array(await response.arrayBuffer());
-    let content = "";
-    const chunk = 8192;
-    for (let i = 0; i < buf.length; i += chunk) {
-        content += String.fromCharCode.apply(null, buf.subarray(i, i + chunk));
-    }
-    return content;
-};

package/dist/old/storage/backupcloud-connection.d.ts

@@ -1,3 +0,0 @@
-import type { Bucket } from "../utils-transport.js";
-export type AwsFetch = (path: string, options?: RequestInit) => Promise<Response>;
-export declare const createCloudClient: (bucket: Bucket) => AwsFetch;

package/dist/old/storage/backupcloud-connection.js

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

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

@@ -1,4 +0,0 @@
-import type { AwsFetch } from "./backupcloud-connection.js";
-export declare const setCloudCacheEntry: (key: string, etag: string, content: string) => Promise<void>;
-export declare const pullFromCloud: (client: AwsFetch) => Promise<void>;
-export declare const mountCloudPull: (client: AwsFetch, signal: AbortSignal) => () => void;

package/dist/old/storage/backupcloud-pull.js

@@ -1,95 +0,0 @@
-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";
-import { decodeCloudContent } from "./_backupcloud.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 listCloud = async (client) => {
-    const listResp = await client("");
-    if (!listResp.ok)
-        throw new Error(`List bucket failed: ${listResp.status}`);
-    const listXml = await listResp.text();
-    return [...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 }) => MONOIDENTITY_SYNC_FOR(key));
-};
-const loadFromCloud = async (objects, client) => {
-    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(key);
-        if (!r.ok)
-            throw new Error(`Fetch ${key} failed: ${r.status}`);
-        const content = await decodeCloudContent(key, r);
-        model[key] = content;
-        nextCache[key] = { etag, content };
-    }));
-    cache = nextCache;
-    await saveCache();
-    return model;
-};
-const _pullFromCloud = async (client) => {
-    const cachePromise = initCache();
-    const objects = await listCloud(client);
-    await cachePromise;
-    const remote = await loadFromCloud(objects, 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 (client) => {
-    const promise = _pullFromCloud(client);
-    addSync("*", promise);
-    await promise;
-};
-export const mountCloudPull = (client, signal) => {
-    signal.throwIfAborted();
-    const syncIntervalId = setInterval(() => {
-        pullFromCloud(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/old/storage/backupcloud-push.d.ts

@@ -1,2 +0,0 @@
-import type { AwsFetch } from "./backupcloud-connection.js";
-export declare const mountCloudPush: (client: AwsFetch, signal: AbortSignal) => () => void;

package/dist/old/storage/backupcloud-push.js

@@ -1,56 +0,0 @@
-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";
-import { encodeCloudContent } from "./_backupcloud.js";
-const write = async (key, value, client) => {
-    console.debug("[monoidentity cloud] saving", key);
-    if (value != undefined) {
-        const r = await client(key, {
-            method: "PUT",
-            headers: { "content-type": "application/octet-stream" },
-            body: encodeCloudContent(key, 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(key, { method: "DELETE" });
-    if (!r.ok && r.status != 404)
-        throw new Error(`DELETE ${key} failed: ${r.status}`);
-};
-export const mountCloudPush = (client, signal) => {
-    signal.throwIfAborted();
-    const writeWrapped = async (key, value) => write(key, value, 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 = MONOIDENTITY_SYNC_FOR(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/old/storage/backuplocally-pull.d.ts

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

package/dist/old/storage/backuplocally-pull.js

@@ -1,58 +0,0 @@
-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/old/storage/backuplocally-push.d.ts

@@ -1 +0,0 @@
-export declare const mountLocalBackupPush: (dir: FileSystemDirectoryHandle, signal: AbortSignal) => () => void;

package/dist/old/storage/backuplocally-push.js

@@ -1,63 +0,0 @@
-import { STORAGE_EVENT } from "./storageclient.svelte.js";
-import { shouldPersist } from "./utils-storage.js";
-import { addSync } from "./utils-sync.js";
-const saveToDir = (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 = MONOIDENTITY_SYNC_FOR(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 = (dir, signal) => {
-    signal.throwIfAborted();
-    const unmount = saveToDir(dir);
-    const cleanup = () => {
-        unmount();
-        signal.removeEventListener("abort", onAbort);
-    };
-    const onAbort = () => {
-        cleanup();
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    return cleanup;
-};

package/dist/old/storage/utils-idb.d.ts

@@ -1 +0,0 @@
-export declare const store: import("idb-keyval").UseStore;

package/dist/old/storage/utils-idb.js

@@ -1,2 +0,0 @@
-import { createStore } from "idb-keyval";
-export const store = createStore("monoidentity-x", "keyval");

package/dist/old/storage/utils-storage.d.ts

@@ -1 +0,0 @@
-export declare const shouldPersist: (key: string) => boolean;

package/dist/old/storage/utils-storage.js

@@ -1 +0,0 @@
-export const shouldPersist = (key) => key.startsWith(".cache/") || key.startsWith(".local/");

package/dist/old/storage/utils-sync.d.ts

@@ -1,13 +0,0 @@
-export type SyncRequestDetail = {
-    key: string;
-    resolve?: () => void;
-    reject?: (reason?: unknown) => void;
-};
-declare global {
-    interface WindowEventMap {
-        "monoidentity-sync-request": CustomEvent<SyncRequestDetail>;
-    }
-}
-export declare const SYNC_REQUEST_EVENT = "monoidentity-sync-request";
-export declare const addSync: (key: string, promise: Promise<void>) => void;
-export declare const scheduleSync: (key: string, fn: () => Promise<void>, delay?: number) => void;

package/dist/old/storage/utils-sync.js

@@ -1,58 +0,0 @@
-export const SYNC_REQUEST_EVENT = "monoidentity-sync-request";
-const activeSyncs = {};
-const scheduledSyncs = {};
-export const addSync = (key, promise) => {
-    const tracked = promise.catch((e) => {
-        console.error(`[monoidentity] ${key} sync failed`, e);
-    });
-    activeSyncs[key] = key in activeSyncs ? activeSyncs[key].then(() => tracked) : tracked;
-};
-const runScheduledSync = async (key) => {
-    const scheduled = scheduledSyncs[key];
-    if (!scheduled)
-        return;
-    delete scheduledSyncs[key];
-    const promise = scheduled.fn();
-    addSync(key, promise);
-    await promise;
-};
-const scheduleInterval = setInterval(() => {
-    const now = Date.now();
-    for (const [key, scheduled] of Object.entries(scheduledSyncs)) {
-        if (scheduled.executeAt <= now) {
-            runScheduledSync(key);
-        }
-    }
-}, 100);
-const waitForTrackedSync = async (key) => {
-    if (key != "*") {
-        await waitForTrackedSync("*");
-    }
-    if (key in activeSyncs) {
-        await activeSyncs[key];
-    }
-    if (key != "*" && key in scheduledSyncs) {
-        await runScheduledSync(key);
-    }
-};
-export const scheduleSync = (key, fn, delay = 1000) => {
-    const executeAt = Date.now() + delay;
-    scheduledSyncs[key] = { fn, executeAt };
-};
-const onSyncRequest = (event) => {
-    const { key, resolve, reject } = event.detail;
-    waitForTrackedSync(key)
-        .then(() => {
-        resolve?.();
-    })
-        .catch((error) => {
-        reject?.(error);
-    });
-};
-addEventListener(SYNC_REQUEST_EVENT, onSyncRequest);
-if (import.meta.hot) {
-    import.meta.hot.dispose(() => {
-        clearInterval(scheduleInterval);
-        removeEventListener(SYNC_REQUEST_EVENT, onSyncRequest);
-    });
-}

package/dist/old/utils-localstorage.d.ts

@@ -1 +0,0 @@
-export declare const canBackup: boolean;

package/dist/old/utils-localstorage.js

@@ -1 +0,0 @@
-export const canBackup = navigator.userAgent.includes("CrOS") && "showDirectoryPicker" in window;

package/dist/utils-base36.d.ts

@@ -1,2 +0,0 @@
-export declare const encode: (text: string) => string;
-export declare const decode: (text: string) => string;

package/dist/utils-base36.js

@@ -1,16 +0,0 @@
-// This isn't encryption, it's just to prevent casual observation of sensitive data
-export const encode = (text) => {
-    const bytes = new TextEncoder().encode(text);
-    let output = "";
-    for (let i = 0; i < bytes.length; i++) {
-        output += bytes[i].toString(36).padStart(2, "0");
-    }
-    return output;
-};
-export const decode = (text) => {
-    const bytes = new Uint8Array(text.length / 2);
-    for (let i = 0; i < text.length; i += 2) {
-        bytes[i / 2] = parseInt(text.slice(i, i + 2), 36);
-    }
-    return new TextDecoder().decode(bytes);
-};

package/dist/utils-transport.d.ts

@@ -1,32 +0,0 @@
-export type Bucket = {
-    base: string;
-    accessKeyId: string;
-    secretAccessKey: string;
-};
-export type Intent = {
-    storage: true;
-} | {
-    loginRecognized: true;
-};
-export type IntentEnvelope = {
-    intents: Intent[];
-    redirectURI: string;
-};
-export type StorageSetup = ({
-    method: "cloud";
-} & Bucket) | {
-    method: "localStorage";
-};
-export type Provision = {
-    setup: StorageSetup;
-} | {
-    createLoginRecognized: string;
-};
-/** @knipexternal */
-export type ProvisionEnvelope = {
-    provisions: Provision[];
-};
-export declare const login: import("valibot", { with: { "resolution-mode": "require" } }).ObjectSchema<{
-    readonly email: import("valibot", { with: { "resolution-mode": "require" } }).SchemaWithPipe<readonly [import("valibot", { with: { "resolution-mode": "require" } }).StringSchema<undefined>, import("valibot", { with: { "resolution-mode": "require" } }).EmailAction<string, undefined>]>;
-    readonly password: import("valibot", { with: { "resolution-mode": "require" } }).StringSchema<undefined>;
-}, undefined>;

package/dist/utils-transport.js

@@ -1,2 +0,0 @@
-import { object, pipe, email, string } from "valibot";
-export const login = object({ email: pipe(string(), email()), password: string() });