@seedprotocol/sdk 0.2.47 → 0.2.49

package/dist/{index-OxV3e-OY.js → index-D3Scq_ka.js}

@@ -2,7 +2,7 @@ import { immerable, produce, enableMapSet } from 'immer';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, setup, assign, waitFor, createActor, raise } from 'xstate';
-import { b as BaseQueryClient, a as BaseEasClient, G as GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY, f as GLOBAL_INITIALIZING_SEND_CONFIG, g as GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES, h as GLOBAL_ADDING_MODELS_TO_DB_SUCCESS, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, d as BROWSER_FS_TOP_DIR, j as DB_CREATING_SUCCESS, k as DB_VALIDATING_SUCCESS, l as DB_VALIDATING_WAIT, m as DB_MIGRATING_SUCCESS, n as DB_WAITING_FOR_FILES_RECEIVED, M as MachineIds, o as DB_MIGRATING_WAIT, p as DbState, I as INTERNAL_VALIDATING_INPUT_SUCCESS, q as ARWEAVE_HOST, B as BaseArweaveClient, c as BaseFileManager, r as INTERNAL_CONFIGURING_FS_SUCCESS, s as INTERNAL_SAVING_CONFIG_SUCCESS, t as INTERNAL_LOADING_APP_DB_SUCCESS, u as DB_ON_SNAPSHOT, v as DB_NAME_APP, w as InternalState, P as PublishMachineStates, x as GlobalState, y as INTERNAL_DATA_TYPES, z as ImageSize, C as internalPropertyNames, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, F as defaultAttestationData } from './constants-Dgv-tSO3.js';
+import { b as BaseQueryClient, a as BaseEasClient, G as GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY, f as GLOBAL_INITIALIZING_SEND_CONFIG, g as GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES, h as GLOBAL_ADDING_MODELS_TO_DB_SUCCESS, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, d as BROWSER_FS_TOP_DIR, j as DB_CREATING_SUCCESS, k as DB_VALIDATING_SUCCESS, l as DB_VALIDATING_WAIT, c as BaseFileManager, m as DB_MIGRATING_SUCCESS, n as DB_WAITING_FOR_FILES_RECEIVED, M as MachineIds, o as DB_MIGRATING_WAIT, p as DbState, I as INTERNAL_VALIDATING_INPUT_SUCCESS, q as ARWEAVE_HOST, B as BaseArweaveClient, r as INTERNAL_CONFIGURING_FS_SUCCESS, s as INTERNAL_SAVING_CONFIG_SUCCESS, t as INTERNAL_LOADING_APP_DB_SUCCESS, u as DB_ON_SNAPSHOT, v as DB_NAME_APP, w as InternalState, P as PublishMachineStates, x as GlobalState, y as INTERNAL_DATA_TYPES, z as ImageSize, C as internalPropertyNames, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, F as defaultAttestationData } from './constants-C03RQQht.js';
 import debug from 'debug';
 import pluralize from 'pluralize';
 import { sqliteTable, text, int, unique } from 'drizzle-orm/sqlite-core';
@@ -10,10 +10,9 @@ import { relations, or, and, isNotNull, not, eq, inArray, sql, like, getTableCol
 import EventEmitter from 'eventemitter3';
 import { customAlphabet } from 'nanoid';
 import * as nanoIdDictionary from 'nanoid-dictionary';
-import { fs } from '@zenfs/core';
+import fs from '@zenfs/core';
 import { throttle, camelCase, startCase, orderBy } from 'lodash-es';
 import { createBrowserInspector } from '@statelyai/inspect';
-import * as fsNode from 'node:fs';
 import path from 'path';
 import Arweave from 'arweave';
 import { BehaviorSubject } from 'rxjs';
@@ -124,6 +123,11 @@ class BaseDb {
     }
 }
 
+var BaseDb$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BaseDb: BaseDb
+});
+
 debug('app:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
@@ -1345,7 +1349,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = await import('./seed.schema.config-Ba_E7t1M.js');
+        const { models: SeedModels } = await import('./seed.schema.config-CS6BvsTl.js');
         const allModels = {
             ...SeedModels,
             ...models$1,
@@ -1522,57 +1526,962 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$k = debug('app:helpers:files');
-/**
- * Waits for a file to exist at the specified path.
- * @param {string} filePath - The path of the file to check.
- * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
- * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
- * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
- */
-const waitForFile = (filePath, interval = 1000, timeout = 60000) => {
-    return new Promise((resolve, reject) => {
-        const startTime = Date.now();
-        let isBusy = false;
-        const _interval = setInterval(async () => {
-            logger$k('waitForFile', filePath);
-            if (isBusy) {
-                return;
+const saveAppState = async (key, value) => {
+    const appDb = BaseDb.getAppDb();
+    await appDb
+        .insert(appState)
+        .values({
+        key,
+        value,
+    })
+        .onConflictDoUpdate({
+        target: appState.key,
+        set: {
+            value,
+        },
+    });
+};
+
+var filesDownload = `(
+  ${function () {
+    const identifyString = (str) => {
+        try {
+            JSON.parse(str);
+            return 'json';
+        }
+        catch (e) {
+            // Not JSON
+        }
+        if (!str) {
+            return;
+        }
+        if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+            return 'html';
+        }
+        // Simple markdown checks (very naive)
+        if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+            return 'markdown';
+        }
+        if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+            return 'base64';
+        }
+        // Default to plain text if unsure
+        return 'text';
+    };
+    const getMimeType = (base64) => {
+        if (!base64) {
+            return null;
+        }
+        const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
+        if (result && result.length > 1) {
+            return result[1];
+        }
+        else {
+            return null; // MIME type could not be determined
+        }
+    };
+    const getDataTypeFromString = (data) => {
+        const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
+        if (nonImageBase64Regex.test(data)) {
+            return 'base64';
+        }
+        // Regular expression for base64 (simple version, checking for base64 format)
+        const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+        if (imageBase64Regex.test(data)) {
+            return 'imageBase64';
+        }
+        // Regular expression for URL (simple version, checking for common URL format)
+        const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
+        if (urlRegex.test(data)) {
+            return 'url';
+        }
+        return null;
+    };
+    const isBinary = (arrayBuffer) => {
+        const view = new Uint8Array(arrayBuffer);
+        let nonTextCount = 0;
+        const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+        for (let i = 0; i < view.length; i++) {
+            const byte = view[i];
+            // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+            if ((byte >= 32 && byte <= 126) || // Printable ASCII
+                byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+            ) {
+                continue;
             }
-            isBusy = true;
-            if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-                clearInterval(_interval);
-                resolve(true);
+            nonTextCount++;
+            if (nonTextCount / view.length > threshold) {
+                return true; // More than threshold are non-text bytes
             }
-            if (Date.now() - startTime >= timeout) {
-                clearInterval(_interval);
-                reject(new Error('Timeout exceeded while waiting for file'));
+        }
+        return false; // Fewer than threshold are non-text bytes
+    };
+    const saveBufferToOPFS = async (filePath, buffer) => {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
+        const fileHandle = await fileHandleAsync.createSyncAccessHandle();
+        // Write the buffer to the file
+        fileHandle.write(buffer);
+        fileHandle.flush();
+        fileHandle.close();
+    };
+    const downloadFiles = async ({ transactionIds, arweaveHost, }) => {
+        let arrayBuffer;
+        for (const transactionId of transactionIds) {
+            try {
+                const response = await fetch(`https://${arweaveHost}/raw/${transactionId}`);
+                arrayBuffer = await response.arrayBuffer();
             }
-            isBusy = false;
-        }, interval);
-        // retry(
-        //   {
-        //     times: Math.ceil(timeout / interval),
-        //     interval: interval,
-        //   },
-        //   (callback: Function) => {
-        //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-        //       return callback(null, true) // File exists, finish with success
-        //     }
-        //     if (Date.now() - startTime >= timeout) {
-        //       return callback(new Error('Timeout exceeded while waiting for file'))
-        //     }
-        //     callback(new Error('File does not exist yet')) // Retry with this error
-        //   },
-        //   (err: Error, result: boolean) => {
-        //     if (err) {
-        //       return resolve(false) // Resolve as false if timeout or error occurs
-        //     }
-        //     resolve(result) // Resolve as true if file exists
+            catch (error) {
+                console.log(`[filesDownload] transaction ${transactionId} data not found`, error);
+                globalThis.postMessage({
+                    message: 'excludeTransaction',
+                    transactionId,
+                });
+                continue;
+            }
+            let dataString;
+            const isBinaryData = isBinary(arrayBuffer);
+            if (!isBinaryData) {
+                const decoder = new TextDecoder('utf-8');
+                const text = decoder.decode(arrayBuffer);
+                dataString = text;
+            }
+            if (!dataString && !arrayBuffer) {
+                console.log(`[filesDownload] transaction ${transactionId} data not found`);
+            }
+            if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
+                const dataStringParts = dataString
+                    .split('===FILE_SEPARATOR===')
+                    .slice(1);
+                if (dataStringParts.length % 2 !== 0) {
+                    throw new Error('Input array must have an even number of elements.');
+                }
+                for (let i = 0; i < dataStringParts.length; i += 2) {
+                    const contentType = dataStringParts[i];
+                    const content = dataStringParts[i + 1];
+                    const encoder = new TextEncoder();
+                    if (contentType === 'html') {
+                        const fileName = `${transactionId}.html`;
+                        const buffer = encoder.encode(content);
+                        saveBufferToOPFS(`/files/html/${fileName}`, buffer);
+                    }
+                    if (contentType === 'json') {
+                        const fileName = `${transactionId}.json`;
+                        const buffer = encoder.encode(content);
+                        saveBufferToOPFS(`/files/json/${fileName}`, buffer);
+                    }
+                }
+                continue;
+            }
+            if (!dataString && arrayBuffer) {
+                saveBufferToOPFS(`/files/images/${transactionId}`, new Uint8Array(arrayBuffer));
+                continue;
+            }
+            if (!dataString) {
+                continue;
+            }
+            let contentType = identifyString(dataString);
+            if (contentType !== 'json' &&
+                contentType !== 'base64' &&
+                contentType !== 'html') {
+                const possibleImageType = getDataTypeFromString(dataString);
+                if (!possibleImageType) {
+                    console.log(`[filesDownload] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    continue;
+                }
+                contentType = possibleImageType;
+            }
+            if (contentType === 'url') {
+                const url = dataString;
+                let buffer;
+                try {
+                    const response = await fetch(url);
+                    buffer = await response.arrayBuffer();
+                }
+                catch (error) {
+                    console.log(`[filesDownload] transaction ${transactionId} value was url: ${dataString} but failed to fetch`, error);
+                    globalThis.postMessage({
+                        message: 'excludeTransaction',
+                        transactionId,
+                    });
+                    continue;
+                }
+                const bufferUint8Array = new Uint8Array(buffer);
+                // Extract the file extension from the URL
+                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
+                if (!extensionMatch) {
+                    throw new Error('Unable to determine the file extension from the URL.');
+                }
+                extensionMatch[0]; // e.g., ".jpg"
+                // Set the file name (you can customize this)
+                // const fileNameFromUrl = `${transactionId}${fileExtension}`
+                await saveBufferToOPFS(`/files/images/${transactionId}`, bufferUint8Array);
+                continue;
+            }
+            const mimeType = getMimeType(dataString);
+            let fileExtension = mimeType;
+            if (fileExtension && fileExtension?.startsWith('image')) {
+                fileExtension = fileExtension.replace('image/', '');
+            }
+            let fileName = transactionId;
+            if (contentType === 'base64') {
+                if (fileExtension) {
+                    fileName += `.${fileExtension}`;
+                }
+                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+                const base64Data = dataString.split(',').pop() || '';
+                // Decode the Base64 string to binary
+                const binaryString = atob(base64Data);
+                const length = binaryString.length;
+                const binaryData = new Uint8Array(length);
+                for (let i = 0; i < length; i++) {
+                    binaryData[i] = binaryString.charCodeAt(i);
+                }
+                await saveBufferToOPFS(`/files/images/${fileName}`, binaryData);
+            }
+            if (contentType === 'html') {
+                fileName += '.html';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(`/files/html/${fileName}`, buffer);
+            }
+            if (contentType === 'json') {
+                fileName += '.json';
+                const encoder = new TextEncoder();
+                const buffer = encoder.encode(dataString);
+                await saveBufferToOPFS(`/files/json/${fileName}`, buffer);
+            }
+        }
+    };
+    onmessage = async (e) => {
+        console.log({
+            message: 'filesDownload onmessage',
+            data: e.data,
+        });
+        await downloadFiles(e.data);
+        globalThis.postMessage({
+            message: 'filesDownload onmessage done',
+            done: true,
+        });
+    };
+}.toString()}
+)()`;
+
+class FileDownloader {
+    constructor() {
+        this.workersArchive = [];
+        this.downloadAll = async ({ transactionIds, arweaveHost, excludedTransactions }) => {
+            if (this.workersArchive.length > 0) {
+                for (let i = 0; i < this.workersArchive.length; i++) {
+                    this.workersArchive[i].terminate();
+                    delete this.workersArchive[i];
+                }
+                this.workersArchive = [];
+            }
+            const worker = new Worker(this.workerBlobUrl);
+            this.workersArchive.push(worker);
+            const localExcludedTransactions = new Set(excludedTransactions);
+            return new Promise((resolve, reject) => {
+                worker.onmessage = (e) => {
+                    console.log('filesDownload main thread onmessage', e.data);
+                    if (e.data.message === 'excludeTransaction') {
+                        localExcludedTransactions.add(e.data.transactionId);
+                    }
+                    if (e.data.done) {
+                        saveAppState('excludedTransactions', JSON.stringify(Array.from(localExcludedTransactions)))
+                            .then(() => {
+                            resolve(e.data);
+                        })
+                            .catch((error) => {
+                            reject(error);
+                        });
+                    }
+                    if (e.data.error) {
+                        reject(e.data.error);
+                    }
+                };
+                worker.postMessage({
+                    transactionIds,
+                    arweaveHost,
+                });
+            });
+        };
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([filesDownload], { type: 'application/javascript' }));
+    }
+}
+
+var imageResize = `(
+  ${function () {
+    async function listFilesInDirectory(directoryHandle) {
+        const entries = [];
+        for await (const [name, handle] of directoryHandle.entries()) {
+            entries.push({
+                name,
+                kind: handle.kind,
+            });
+        }
+        return entries;
+    }
+    const getFileHandle = async (path, rootHandle = null) => {
+        // Split the path into segments
+        const segments = path.split('/').filter(Boolean);
+        // Start from the root directory if not provided
+        if (!rootHandle) {
+            rootHandle = await navigator.storage.getDirectory();
+        }
+        let currentHandle = rootHandle;
+        // Traverse the path segments
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const isLastSegment = i === segments.length - 1;
+            try {
+                for await (const [name, handle] of currentHandle.entries()) {
+                    if (name !== segment) {
+                        continue;
+                    }
+                    if (isLastSegment) {
+                        if (handle.kind === 'file') {
+                            return handle; // Return the file handle if found
+                        }
+                        else {
+                            throw new Error(`Path '${path}' refers to a directory, not a file.`);
+                        }
+                    }
+                    else if (handle.kind === 'directory') {
+                        currentHandle = handle; // Traverse into the directory
+                    }
+                    else {
+                        throw new Error(`Invalid path segment '${segment}'`);
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'NotFoundError') {
+                    throw new Error(`Path '${path}' does not exist.`);
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        throw new Error(`Path '${path}' could not be resolved.`);
+    };
+    async function getFileFromOPFS(path) {
+        const fileHandleAsync = await getFileHandle(path);
+        const file = await fileHandleAsync.getFile();
+        return file;
+    }
+    const DEFAULT_CONFIG = {
+        argorithm: 'null',
+        processByHalf: true,
+        quality: 0.5,
+        maxWidth: 800,
+        maxHeight: 600,
+        debug: false,
+        mimeType: 'image/jpeg',
+    };
+    function isIos() {
+        if (typeof navigator === 'undefined')
+            return false;
+        if (!navigator.userAgent)
+            return false;
+        return /iPad|iPhone|iPod/.test(navigator.userAgent);
+    }
+    const getTargetHeight = (srcHeight, scale, config) => {
+        return Math.min(Math.floor(srcHeight * scale), config.maxHeight);
+    };
+    const findMaxWidth = (config, canvas) => {
+        //Let's find the max available width for scaled image
+        const ratio = canvas.width / canvas.height;
+        let mWidth = Math.min(canvas.width, config.maxWidth, ratio * config.maxHeight);
+        if (config.maxSize &&
+            config.maxSize > 0 &&
+            config.maxSize < (canvas.width * canvas.height) / 1000)
+            mWidth = Math.min(mWidth, Math.floor((config.maxSize * 1000) / canvas.height));
+        if (!!config.scaleRatio)
+            mWidth = Math.min(mWidth, Math.floor(config.scaleRatio * canvas.width));
+        const rHeight = getTargetHeight(canvas.height, mWidth / canvas.width, config);
+        // console.log(
+        //   'browser-image-resizer: original image size = ' +
+        //   canvas.width +
+        //   ' px (width) X ' +
+        //   canvas.height +
+        //   ' px (height)'
+        // );
+        // console.log(
+        //   'browser-image-resizer: scaled image size = ' +
+        //   mWidth +
+        //   ' px (width) X ' +
+        //   rHeight +
+        //   ' px (height)'
+        // );
+        if (mWidth <= 0) {
+            mWidth = 1;
+            console.warn("browser-image-resizer: image size is too small");
+        }
+        if (isIos() && mWidth * rHeight > 167777216) {
+            console.error("browser-image-resizer: image size is too large for iOS WebKit.", mWidth, rHeight);
+            throw new Error("browser-image-resizer: image size is too large for iOS WebKit.");
+        }
+        return mWidth;
+    };
+    /**
+    * Hermite resize, multicore version - fast image resize/resample using Hermite filter.
+    */
+    const resample = (srcCanvas, destCanvas, config) => {
+        return new Promise((resolve, reject) => {
+            const ratio_h = srcCanvas.height / destCanvas.height;
+            const cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+            //prepare source and target data for workers
+            const ctx = srcCanvas.getContext('2d');
+            if (!ctx)
+                return reject('Canvas is empty (resample)');
+            const data_part = [];
+            const block_height = Math.ceil(srcCanvas.height / cores / 2) * 2;
+            let end_y = -1;
+            for (let c = 0; c < cores; c++) {
+                //source
+                const offset_y = end_y + 1;
+                if (offset_y >= srcCanvas.height) {
+                    //size too small, nothing left for this core
+                    continue;
+                }
+                end_y = Math.min(offset_y + block_height - 1, srcCanvas.height - 1);
+                const current_block_height = Math.min(block_height, srcCanvas.height - offset_y);
+                console.log('browser-image-resizer: source split: ', '#' + c, offset_y, end_y, 'height: ' + current_block_height);
+                data_part.push({
+                    source: ctx.getImageData(0, offset_y, srcCanvas.width, block_height),
+                    startY: Math.ceil(offset_y / ratio_h),
+                    height: current_block_height
+                });
+            }
+            //start
+            const destCtx = destCanvas.getContext('2d');
+            if (!destCtx)
+                return reject('Canvas is empty (resample dest)');
+            for (let c = 0; c < data_part.length; c++) {
+                //draw
+                const height_part = Math.ceil(data_part[c].height / ratio_h);
+                const target = destCtx.createImageData(destCanvas.width, height_part);
+                // target.data.set(event.data.target);
+                destCtx.putImageData(target, 0, data_part[c].startY);
+            }
+        });
+    };
+    /**
+     * Hermite resize - fast image resize/resample using Hermite filter. 1 cpu version!
+     */
+    const resampleSingle = (srcCanvasData, destCanvasData) => {
+        const ratio_w = srcCanvasData.width / destCanvasData.width;
+        const ratio_h = srcCanvasData.height / destCanvasData.height;
+        const ratio_w_half = Math.ceil(ratio_w / 2);
+        const ratio_h_half = Math.ceil(ratio_h / 2);
+        const data = srcCanvasData.data;
+        const data2 = destCanvasData.data;
+        for (let j = 0; j < destCanvasData.height; j++) {
+            for (let i = 0; i < destCanvasData.width; i++) {
+                const x2 = (i + j * destCanvasData.width) * 4;
+                let weight = 0;
+                let weights = 0;
+                let weights_alpha = 0;
+                let gx_r = 0;
+                let gx_g = 0;
+                let gx_b = 0;
+                let gx_a = 0;
+                const center_y = j * ratio_h;
+                const xx_start = Math.floor(i * ratio_w);
+                const xx_stop = Math.min(Math.ceil((i + 1) * ratio_w), srcCanvasData.width);
+                const yy_start = Math.floor(j * ratio_h);
+                const yy_stop = Math.min(Math.ceil((j + 1) * ratio_h), srcCanvasData.height);
+                for (let yy = yy_start; yy < yy_stop; yy++) {
+                    let dy = Math.abs(center_y - yy) / ratio_h_half;
+                    let center_x = i * ratio_w;
+                    let w0 = dy * dy; //pre-calc part of w
+                    for (let xx = xx_start; xx < xx_stop; xx++) {
+                        let dx = Math.abs(center_x - xx) / ratio_w_half;
+                        let w = Math.sqrt(w0 + dx * dx);
+                        if (w >= 1) {
+                            //pixel too far
+                            continue;
+                        }
+                        //hermite filter
+                        weight = 2 * w * w * w - 3 * w * w + 1;
+                        let pos_x = 4 * (xx + yy * srcCanvasData.width);
+                        //alpha
+                        gx_a += weight * data[pos_x + 3];
+                        weights_alpha += weight;
+                        //colors
+                        if (data[pos_x + 3] < 255)
+                            weight = weight * data[pos_x + 3] / 250;
+                        gx_r += weight * data[pos_x];
+                        gx_g += weight * data[pos_x + 1];
+                        gx_b += weight * data[pos_x + 2];
+                        weights += weight;
+                    }
+                }
+                data2[x2] = gx_r / weights;
+                data2[x2 + 1] = gx_g / weights;
+                data2[x2 + 2] = gx_b / weights;
+                data2[x2 + 3] = gx_a / weights_alpha;
+            }
+        }
+    };
+    /**
+    * Hermite resize. Detect cpu count and use best option for user.
+    */
+    const resampleAuto = (srcCanvas, destCanvas, config) => {
+        if (!!globalThis.Worker && navigator.hardwareConcurrency > 1 && config?.argorithm !== 'hermite_single') {
+            //workers supported and we have at least 2 cpu cores - using multithreading
+            return resample(srcCanvas, destCanvas);
+        }
+        else {
+            //1 cpu version
+            const { srcImgData, destImgData } = getImageData(srcCanvas, destCanvas);
+            resampleSingle(srcImgData, destImgData);
+            destCanvas.getContext('2d').putImageData(destImgData, 0, 0);
+            return;
+        }
+    };
+    async function scaleCanvasWithAlgorithm(canvas, config) {
+        const scale = config.outputWidth / canvas.width;
+        const scaled = new OffscreenCanvas(Math.floor(config.outputWidth), getTargetHeight(canvas.height, scale, config));
+        switch (config.algorithm) {
+            case 'hermite': {
+                await resampleAuto(canvas, scaled, config);
+                break;
+            }
+            case 'hermite_single': {
+                const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                resampleSingle(srcImgData, destImgData);
+                scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            case 'bilinear': {
+                // const { srcImgData, destImgData } = getImageData(canvas, scaled);
+                // bilinear(srcImgData, destImgData, scale);
+                // scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
+                break;
+            }
+            default: {
+                scaled.getContext('2d')?.drawImage(canvas, 0, 0, scaled.width, scaled.height);
+                break;
+            }
+        }
+        return scaled;
+    }
+    const getHalfScaleCanvas = (src) => {
+        const half = new OffscreenCanvas(src.width / 2, src.height / 2);
+        half
+            ?.getContext('2d')
+            ?.drawImage(src, 0, 0, half.width, half.height);
+        return half;
+    };
+    const getImageData = (canvas, scaled) => {
+        const srcImgData = canvas
+            ?.getContext('2d')
+            ?.getImageData(0, 0, canvas.width, canvas.height);
+        const destImgData = scaled
+            ?.getContext('2d')
+            ?.createImageData(scaled.width, scaled.height);
+        if (!srcImgData || !destImgData)
+            throw Error('Canvas is empty (scaleCanvasWithAlgorithm). You should run this script after the document is ready.');
+        return { srcImgData, destImgData };
+    };
+    async function saveBlobToOPFS(filePath, blob) {
+        // Access the OPFS root directory
+        const rootHandle = await navigator.storage.getDirectory();
+        // Split the filePath into directory segments and file name
+        const segments = filePath.split('/').filter(Boolean);
+        const fileName = segments.pop(); // Extract the file name
+        if (!fileName) {
+            throw new Error('Invalid file path: No file name provided.');
+        }
+        // Traverse or create directories as needed
+        let currentDirHandle = rootHandle;
+        for (const segment of segments) {
+            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
+        }
+        // Create or open the file in OPFS
+        const fileHandle = await currentDirHandle.getFileHandle(fileName, { create: true });
+        // Write the Blob to the file
+        const writableStream = await fileHandle.createWritable();
+        await writableStream.write(blob);
+        await writableStream.close();
+    }
+    const imageResize = async (filePath, width, height) => {
+        console.log({ filePath, width, height });
+        const config = {
+            ...DEFAULT_CONFIG,
+            algorithm: 'hermite_single',
+            mimeType: 'image/webp',
+            maxWidth: width,
+            maxHeight: height,
+        };
+        const rootHandle = await navigator.storage.getDirectory();
+        // List files in the root directory
+        const files = await listFilesInDirectory(rootHandle);
+        console.log({
+            message: 'listFilesInDirectory',
+            files
+        });
+        const file = await getFileFromOPFS(filePath);
+        const imageBitmap = await createImageBitmap(file);
+        let converting;
+        if (isIos() && imageBitmap.width * imageBitmap.height > 16777216) {
+            const scale = Math.sqrt(16777216 / (imageBitmap.width * imageBitmap.height));
+            console.log(`browser-image-resizer: scale: Image is too large in iOS WebKit`);
+            converting = new OffscreenCanvas(Math.floor(imageBitmap.width * scale), Math.floor(imageBitmap.height * scale));
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0, converting.width, converting.height);
+        }
+        else {
+            converting = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0);
+        }
+        if (!converting?.getContext('2d')) {
+            console.log('browser-image-resizer: Canvas Context is empty.');
+        }
+        const maxWidth = findMaxWidth(config, converting);
+        if (!maxWidth) {
+            throw Error(`browser-image-resizer: maxWidth is ${maxWidth}!!`);
+        }
+        while (config.processByHalf && converting.width >= 2 * maxWidth) {
+            if (config.debug)
+                console.log(`browser-image-resizer: scale: Scaling canvas by half from ${converting.width}`);
+            converting = getHalfScaleCanvas(converting);
+        }
+        if (converting.width > maxWidth) {
+            if (config.debug)
+                console.log(`browser-image-resizer: scale: Scaling canvas by ${config.argorithm} from ${converting.width} to ${maxWidth}`);
+            converting = await scaleCanvasWithAlgorithm(converting, Object.assign(config, { outputWidth: maxWidth }));
+        }
+        if (config.mimeType === null) {
+            return converting;
+        }
+        const resizedBlob = await converting.convertToBlob({ type: config.mimeType, quality: config.quality });
+        const pathSegments = filePath.split('/');
+        const fileName = pathSegments.pop();
+        if (!fileName) {
+            throw Error('Invalid file path: No file name provided.');
+        }
+        const newSegments = [
+            ...pathSegments,
+            width,
+        ];
+        const fileNameParts = fileName.split('.');
+        const newFileName = `${fileNameParts[0]}.webp`;
+        const newDirPath = newSegments.join('/');
+        const newFilePath = `${newDirPath}/${newFileName}`;
+        // Save resized image to OPFS with new name
+        await saveBlobToOPFS(newFilePath, resizedBlob);
+        globalThis.postMessage({
+            done: true,
+            filePath: newFilePath,
+        });
+    };
+    onmessage = async (e) => {
+        console.log('[imageResize] onmessage', e.data);
+        const { filePath, width, height } = e.data;
+        await imageResize(filePath, width, height);
+        console.log(`[imageResize] Done`, filePath);
+    };
+}.toString()}
+)()`;
+
+class ImageResizer {
+    constructor() {
+        this.workersArchive = new Map();
+        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
+        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([imageResize], { type: 'application/javascript' }));
+    }
+    async resize({ filePath, width, height }) {
+        if (this.workersArchive.has(filePath)) {
+            const savedWorker = this.workersArchive.get(filePath);
+            savedWorker?.terminate();
+            console.log('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath);
+            this.workersArchive.delete(filePath);
+        }
+        const worker = new Worker(this.workerBlobUrl);
+        this.workersArchive.set(filePath, worker);
+        return new Promise((resolve, reject) => {
+            worker.onmessage = (e) => {
+                console.log('[ImageResizer.resize] main thread onmessage', e.data);
+                if (e.data.done) {
+                    const savedWorker = this.workersArchive.get(filePath);
+                    savedWorker?.terminate();
+                    console.log('[ImageResizer.resize] Terminated worker for filePath due to done', filePath);
+                    this.workersArchive.delete(filePath);
+                    resolve(e.data);
+                }
+                if (e.data.error) {
+                    reject(e.data.error);
+                }
+            };
+            worker.postMessage({
+                filePath,
+                width,
+                height,
+            });
+        });
+    }
+    async resizeAll({ width, height }) {
+        const imageDir = '/files/images';
+        let imageFilesStats = await fs.promises.readdir(imageDir, {
+            withFileTypes: true
+        });
+        imageFilesStats = imageFilesStats.filter(file => file.isFile());
+        const imageFiles = imageFilesStats.map(file => file.path);
+        const widthDir = `${imageDir}/${width}`;
+        await FileManager.createDirIfNotExists(widthDir);
+        for (const imageFile of imageFiles) {
+            const resizedImageExists = await fs.promises.exists(`${widthDir}/${imageFile}`);
+            if (!resizedImageExists) {
+                await this.resize({ filePath: `${imageDir}/${imageFile}`, width, height });
+            }
+        }
+    }
+}
+
+const logger$k = debug('app:browser:helpers:FileManager');
+class FileManager extends BaseFileManager {
+    static async readFileAsBuffer(filePath) {
+        return new Promise((resolve, reject) => {
+            reject(new Error('Not implemented'));
+        });
+    }
+    static async getContentUrlFromPath(path) {
+        const fs = await import('@zenfs/core');
+        const fileExists = await fs.promises.exists(path);
+        if (fileExists) {
+            const fileContents = await fs.promises.readFile(path);
+            const fileHandler = new File([fileContents], path);
+            return URL.createObjectURL(fileHandler);
+        }
+    }
+    static async initializeFileSystem() {
+        const { WebAccess } = await import('@zenfs/dom');
+        const { configureSingle } = await import('@zenfs/core');
+        const handle = await navigator.storage.getDirectory();
+        // await configure({
+        //   mounts: {
+        //     '/': {
+        //       backend: WebAccess,
+        //       handle,
+        //     },
         //   },
-        // )
-    });
-};
+        //   disableUpdateOnRead: true,
+        //   onlySyncOnClose: true,
+        // })
+        await configureSingle({
+            backend: WebAccess,
+            handle,
+        });
+    }
+    static async downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions, }) {
+        const fileDownloader = new FileDownloader();
+        await fileDownloader.downloadAll({ transactionIds, arweaveHost, excludedTransactions });
+    }
+    static async resizeImage({ filePath, width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resize({ filePath, width, height });
+    }
+    static async resizeAllImages({ width, height }) {
+        const imageResizer = new ImageResizer();
+        await imageResizer.resizeAll({ width, height });
+    }
+    static async pathExists(filePath) {
+        try {
+            // Access the root directory of OPFS
+            const root = await navigator.storage.getDirectory();
+            // Split the path into segments
+            const parts = filePath.split('/').filter(Boolean);
+            let currentDir = root;
+            // Traverse each part of the path
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                try {
+                    const handle = await currentDir.getDirectoryHandle(part, { create: false });
+                    currentDir = handle; // Move into the directory
+                }
+                catch (error) {
+                    try {
+                        // If it's not a directory, check if it's a file
+                        await currentDir.getFileHandle(part, { create: false });
+                        // If we successfully got a file handle and it's the last part, return true
+                        return i === parts.length - 1;
+                    }
+                    catch {
+                        // Neither a directory nor a file exists
+                        return false;
+                    }
+                }
+            }
+            return true; // Directory exists
+        }
+        catch (error) {
+            return false; // Any error means the path does not exist
+        }
+    }
+    static async createDirIfNotExists(filePath) {
+        if (!(await FileManager.pathExists(filePath))) {
+            try {
+                const fs = await import('@zenfs/core');
+                await fs.promises.mkdir(filePath);
+            }
+            catch (error) {
+                // This is a no-op. We tried to create a directory that already exists.
+                console.log('Attempted to create a directory that already exists');
+            }
+        }
+    }
+    /**
+     * Waits for a file to exist at the specified path.
+     * @param {string} filePath - The path of the file to check.
+     * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
+     * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
+     * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
+     */
+    static async waitForFile(filePath, interval = 1000, timeout = 60000) {
+        const fs = await import('@zenfs/core');
+        const fsNode = await import('node:fs');
+        return new Promise((resolve, reject) => {
+            const startTime = Date.now();
+            let isBusy = false;
+            const cancelableInterval = new CancelableInterval(async (stop) => {
+                logger$k('waitForFile', filePath);
+                if (isBusy) {
+                    return;
+                }
+                isBusy = true;
+                // TODO: Needs to read from OPFS
+                if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+                    stop();
+                    resolve(true);
+                }
+                const pathExists = await this.pathExists(filePath);
+                if (pathExists) {
+                    stop();
+                    resolve(true);
+                }
+                if (Date.now() - startTime >= timeout) {
+                    stop();
+                    reject(new Error('Timeout exceeded while waiting for file'));
+                }
+                isBusy = false;
+            }, interval);
+            cancelableInterval.start();
+            // const _interval = setInterval(async () => {
+            //   logger('waitForFile', filePath)
+            //   if (isBusy) {
+            //     return
+            //   }
+            //   isBusy = true
+            //   // TODO: Needs to read from OPFS
+            //   if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   const pathExists = await this.pathExists(filePath)
+            //   if (pathExists) {
+            //     clearInterval(_interval)
+            //     resolve(true)
+            //   }
+            //   if (Date.now() - startTime >= timeout) {
+            //     clearInterval(_interval)
+            //     reject(new Error('Timeout exceeded while waiting for file'))
+            //   }
+            //   isBusy = false
+            // }, interval)
+            // retry(
+            //   {
+            //     times: Math.ceil(timeout / interval),
+            //     interval: interval,
+            //   },
+            //   (callback: Function) => {
+            //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+            //       return callback(null, true) // File exists, finish with success
+            //     }
+            //     if (Date.now() - startTime >= timeout) {
+            //       return callback(new Error('Timeout exceeded while waiting for file'))
+            //     }
+            //     callback(new Error('File does not exist yet')) // Retry with this error
+            //   },
+            //   (err: Error, result: boolean) => {
+            //     if (err) {
+            //       return resolve(false) // Resolve as false if timeout or error occurs
+            //     }
+            //     resolve(result) // Resolve as true if file exists
+            //   },
+            // )
+        });
+    }
+}
+BaseFileManager.setPlatformClass(FileManager);
+class CancelableInterval {
+    constructor(task, interval) {
+        this.task = task;
+        this.interval = interval;
+        this.intervalId = null;
+        this.currentTaskAbortController = null;
+    }
+    start() {
+        this.intervalId = window.setInterval(async () => {
+            if (this.currentTaskAbortController) {
+                // Cancel the previous running task
+                this.currentTaskAbortController.abort();
+            }
+            // Create a new abort controller for the current task
+            this.currentTaskAbortController = new AbortController();
+            const signal = this.currentTaskAbortController.signal;
+            try {
+                await this.taskWithCancellation(signal);
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    console.log('Previous task was canceled.');
+                }
+                else {
+                    console.error('Task error:', error);
+                }
+                this.stop();
+            }
+        }, this.interval);
+    }
+    async taskWithCancellation(signal) {
+        await this.task(() => this.stop());
+        if (signal.aborted) {
+            throw new DOMException('Task was aborted', 'AbortError');
+        }
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.currentTaskAbortController) {
+            this.currentTaskAbortController.abort();
+        }
+    }
+}
+
+var FileManager$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FileManager: FileManager
+});
 
 const logger$j = debug('app:services:db:actors:migrate');
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
@@ -1583,7 +2492,7 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
         const journalPath = `/${pathToDbDir}/meta/_journal.json`;
         journalExists = await fs.promises.exists(journalPath);
         if (!journalExists) {
-            await waitForFile(journalPath, 500, 60000);
+            await FileManager.waitForFile(journalPath, 500, 60000);
         }
     };
     const _migrate = async () => {
@@ -1831,26 +2740,22 @@ const createDirectories = async (dirPath) => {
         return;
     }
     const parentDir = path.dirname(dirPath);
-    let parentDirExists = await fs.promises.exists(parentDir);
+    let parentDirExists = await BaseFileManager.pathExists(parentDir);
     if (!parentDirExists) {
         await createDirectories(parentDir);
     }
-    parentDirExists = await fs.promises.exists(parentDir);
+    parentDirExists = await BaseFileManager.pathExists(parentDir);
     if (parentDirExists) {
-        try {
-            await fs.promises.mkdir(dirPath);
-        }
-        catch (error) {
-            logger$h(`[Error] Failed to create directories for ${dirPath}:`, error);
-        }
-    }
-    if (!parentDirExists) {
-        console.log(fs);
+        await BaseFileManager.createDirIfNotExists(dirPath);
     }
 };
-let busy = false;
-const downloadFile = async (url, localFilePath) => {
-    try {
+class FileDownloadManager {
+    constructor(fileUrls, maxRetries) {
+        this.isDownloading = false;
+        this.filesToDownload = new Map(fileUrls.map(url => [url, 0]));
+        this.maxRetries = maxRetries;
+    }
+    async downloadFile(url, localFilePath) {
         const response = await fetch(url);
         const fileData = await response.text().catch((error) => {
             console.error(`Failed to parse text from ${url}:`, error);
@@ -1860,10 +2765,6 @@ const downloadFile = async (url, localFilePath) => {
             return;
         }
         const localDirPath = path.dirname(localFilePath);
-        if (busy) {
-            return;
-        }
-        busy = true;
         await createDirectories(localDirPath);
         const filename = path.basename(localFilePath);
         const regex = /(\d+)[\w_]+\.(sql|json)$/;
@@ -1899,34 +2800,77 @@ const downloadFile = async (url, localFilePath) => {
             logger$h(`[downloadFile] Wrote file sync to ${localFilePath}`);
         }
     }
-    catch (error) {
-        logger$h(`[Error] Failed to download file from ${url}:`, error);
+    async start() {
+        if (this.isDownloading) {
+            console.warn("Download process is already running.");
+            return;
+        }
+        this.isDownloading = true;
+        for (const [fileUrl, attempts] of this.filesToDownload.entries()) {
+            let success = false;
+            while (attempts < this.maxRetries) {
+                try {
+                    console.log(`Starting download: ${fileUrl}`);
+                    await this.downloadFile(fileUrl, fileUrl);
+                    console.log(`Download successful: ${fileUrl}`);
+                    this.filesToDownload.delete(fileUrl);
+                    success = true;
+                    break; // Move to next file
+                }
+                catch (error) {
+                    console.error(`Error downloading ${fileUrl}:`, error);
+                    this.filesToDownload.set(fileUrl, attempts + 1);
+                }
+            }
+            if (!success) {
+                console.error(`Failed to download after ${this.maxRetries} attempts: ${fileUrl}`);
+            }
+        }
+        this.isDownloading = false;
+        console.log("All downloads completed.");
     }
-    busy = false;
-};
-const fetchDirectory = async (url) => {
-    const response = await fetch(url);
-    return response.json();
-};
-const fetchFilesRecursively = async (url, localPath, fileList) => {
-    for (const file of fileList) {
-        try {
-            const fileUrl = `${url}/${file}`;
-            const fileLocalPath = path.join(localPath, file);
-            // logger(`[fetchFilesRecursively] fileUrl: ${fileUrl}`)
-            // logger(`[fetchFilesRecursively] fileLocalPath: ${fileLocalPath}`)
-            await downloadFile(fileUrl, fileLocalPath);
+    addFile(fileUrl) {
+        if (!this.filesToDownload.has(fileUrl)) {
+            this.filesToDownload.set(fileUrl, 0);
+            console.log(`Added file to download queue: ${fileUrl}`);
         }
-        catch (error) {
-            console.error(`Failed to fetch files from ${url}:`, error);
+        else {
+            console.warn(`File already in queue: ${fileUrl}`);
         }
     }
+    getPendingFiles() {
+        return Array.from(this.filesToDownload.keys());
+    }
+    clear() {
+        this.filesToDownload.clear();
+        console.log("Cleared all files from the download queue.");
+    }
+}
+const fetchDirectory = async (url) => {
+    const response = await fetch(url);
+    return response.json();
 };
+// export const fetchFilesRecursively = async (
+//   url: string,
+//   localPath: string,
+//   fileList: string[],
+// ) => {
+//   for (const file of fileList) {
+//     try {
+//       const fileUrl = `${url}/${file}`
+//       const fileLocalPath = path.join(localPath, file)
+//       // logger(`[fetchFilesRecursively] fileUrl: ${fileUrl}`)
+//       // logger(`[fetchFilesRecursively] fileLocalPath: ${fileLocalPath}`)
+//       await downloadFile(fileUrl, fileLocalPath)
+//     } catch (error) {
+//       console.error(`Failed to fetch files from ${url}:`, error)
+//     }
+//   }
+// }
 const confirmFilesExist = async (filePaths) => {
     let everythingDownloaded = false;
     for (const filePath of filePaths) {
-        const fullPath = path.join(BROWSER_FS_TOP_DIR, filePath);
-        everythingDownloaded = await fs.promises.exists(fullPath);
+        everythingDownloaded = await fs.promises.exists(filePath);
     }
     if (!everythingDownloaded) {
         setTimeout(async () => {
@@ -1938,7 +2882,10 @@ const filesToExclude = ['.DS_Store'];
 const syncDbFiles = async ({ filePaths, files }) => {
     let fileList = await fetchDirectory(filePaths);
     fileList = fileList.filter((file) => !filesToExclude.includes(file));
-    await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
+    fileList = fileList.map((file) => `${files}/${file}`);
+    const downloadManager = new FileDownloadManager(fileList, 5);
+    await downloadManager.start();
+    // await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList)
     await confirmFilesExist(fileList);
     logger$h('[syncDbFiles] Files synced!');
 };
@@ -2031,28 +2978,12 @@ const GET_TRANSACTION_TAGS = graphql(/* GraphQL */ `
   }
 `);
 
-const saveAppState = async (key, value) => {
-    const appDb = BaseDb.getAppDb();
-    await appDb
-        .insert(appState)
-        .values({
-        key,
-        value,
-    })
-        .onConflictDoUpdate({
-        target: appState.key,
-        set: {
-            value,
-        },
-    });
-};
-
 const initArweaveClient = async () => {
     if (isBrowser()) {
-        (await import('./ArweaveClient-DQrXvrNN.js')).ArweaveClient;
+        (await import('./ArweaveClient-Dcqcpsq4.js')).ArweaveClient;
     }
     if (!isBrowser()) {
-        (await import('./ArweaveClient-CoFomTCN.js')).ArweaveClient;
+        (await import('./ArweaveClient-Dh7LRIqD.js')).ArweaveClient;
     }
 };
 let domain = 'arweave.net';
@@ -2138,18 +3069,10 @@ const downloadAllFilesBinaryRequestHandler = async () => {
             },
         }),
     });
-    if (!(await fs.promises.exists('/files'))) {
-        await fs.promises.mkdir('/files', { recursive: true });
-    }
-    if (!(await fs.promises.exists('/files/html'))) {
-        await fs.promises.mkdir('/files/html', { recursive: true });
-    }
-    if (!(await fs.promises.exists('/files/json'))) {
-        await fs.promises.mkdir('/files/json', { recursive: true });
-    }
-    if (!(await fs.promises.exists('/files/images'))) {
-        await fs.promises.mkdir('/files/images', { recursive: true });
-    }
+    await BaseFileManager.createDirIfNotExists('/files');
+    await BaseFileManager.createDirIfNotExists('/files/html');
+    await BaseFileManager.createDirIfNotExists('/files/json');
+    await BaseFileManager.createDirIfNotExists('/files/images');
     const appDb = BaseDb.getAppDb();
     if (!appDb) {
         console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available');
@@ -4932,7 +5855,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await import('./index-CAikKppg.js');
+            const { Item } = await import('./index-Dp3GcggF.js');
             const item = await Item.find({
                 seedLocalId,
                 modelName,
@@ -6519,7 +7442,7 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     }
     const seedType = modelName.toLowerCase();
     const newSeedId = await createSeed({ type: seedType });
-    const newVersionId = await createVersion({ seedLocalId: newSeedId });
+    const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase$1(modelName) });
     const propertySchemas = getModel(modelName)?.schema;
     for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
         let propertyRecordSchema;
@@ -6534,6 +7457,7 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
             modelName,
         }, propertyRecordSchema);
     }
+    eventEmitter.emit('item.requestAll', { modelName });
     return {
         modelName,
         seedLocalId: newSeedId,
@@ -6715,7 +7639,7 @@ class BaseItem {
         if (!props.modelName) {
             throw new Error('Model name is required to create an item');
         }
-        const { seedLocalId, versionLocalId, versionUid } = await createNewItem({
+        const { seedLocalId, versionLocalId, } = await createNewItem({
             modelName: props.modelName,
         });
         props.seedLocalId = seedLocalId;
@@ -6804,6 +7728,9 @@ class BaseItem {
     get latestVersionUid() {
         return this.serviceContext.latestVersionUid;
     }
+    get latestVersionLocalId() {
+        return this.serviceContext.latestVersionLocalId;
+    }
     get modelName() {
         return this.serviceContext.modelName;
     }
@@ -6813,6 +7740,12 @@ class BaseItem {
     get attestationCreatedAt() {
         return this.serviceContext.attestationCreatedAt;
     }
+    get versionsCount() {
+        return this.serviceContext.versionsCount;
+    }
+    get lastVersionPublishedAt() {
+        return this.serviceContext.lastVersionPublishedAt;
+    }
     unload() {
         this._subscription?.unsubscribe();
         this._service.stop();
@@ -6865,7 +7798,7 @@ const initItem = async () => {
         Item$2 = (await Promise.resolve().then(function () { return Item$1; })).Item;
     }
     if (!isBrowser()) {
-        Item$2 = (await import('./Item-DOEEhWwi.js')).Item;
+        Item$2 = (await import('./Item-7vg6XRhw.js')).Item;
     }
 };
 
@@ -6875,17 +7808,17 @@ const initItemProperty = async () => {
         ItemProperty$2 = (await Promise.resolve().then(function () { return ItemProperty$1; })).ItemProperty;
     }
     if (!isBrowser()) {
-        ItemProperty$2 = (await import('./ItemProperty-CABHeoKm.js')).ItemProperty;
+        ItemProperty$2 = (await import('./ItemProperty-Bcht9WTV.js')).ItemProperty;
     }
 };
 
 let Db;
 const initDb = async () => {
     if (isBrowser()) {
-        Db = (await import('./Db-Dv7s24Zi.js')).Db;
+        Db = (await import('./Db-CMRjCZoY.js')).Db;
     }
     if (!isBrowser()) {
-        Db = (await import('./Db-Dgbci7BP.js')).Db;
+        Db = (await import('./Db-BjoRtCFg.js')).Db;
     }
     // TODO: Add config for React Native
 };
@@ -7337,6 +8270,7 @@ const useItems = ({ modelName, deleted = false }) => {
             }
             listenerRef.current();
         });
+        readFromDb();
         return () => {
             eventEmitter.removeListener('item.requestAll', readFromDb);
         };
@@ -7669,28 +8603,28 @@ const setupServiceHandlers = () => {
 
 const initEasClient = async () => {
     if (isBrowser()) {
-        (await import('./EasClient-sCbTHcO8.js')).EasClient;
+        (await import('./EasClient-A1xC7Gm-.js')).EasClient;
     }
     if (!isBrowser()) {
-        (await import('./EasClient-CBu9ENAi.js')).EasClient;
+        (await import('./EasClient-m2mXad59.js')).EasClient;
     }
 };
 
 const initQueryClient = async () => {
     if (isBrowser()) {
-        (await import('./QueryClient-BBaE-LKI.js')).QueryClient;
+        (await import('./QueryClient-C-hFMF2j.js')).QueryClient;
     }
     if (!isBrowser()) {
-        (await import('./QueryClient-C-ZzUnWq.js')).QueryClient;
+        (await import('./QueryClient-C02sPZ-K.js')).QueryClient;
     }
 };
 
 const initFileManager = async () => {
     if (isBrowser()) {
-        (await import('./FileManager-Np-xCJ1X.js')).FileManager;
+        (await Promise.resolve().then(function () { return FileManager$1; })).FileManager;
     }
     if (!isBrowser()) {
-        (await import('./FileManager-COOp89Mj.js')).FileManager;
+        (await import('./FileManager-Dv2zn1RW.js')).FileManager;
     }
 };
 
@@ -7736,11 +8670,35 @@ const client = {
             arweaveDomain,
             filesDir,
         });
-        const { models: internalModels } = await import('./seed.schema.config-Ba_E7t1M.js');
+        const { models: internalModels } = await import('./seed.schema.config-CS6BvsTl.js');
         for (const [key, value] of Object.entries(internalModels)) {
             setModel(key, value);
         }
     },
+    setAddresses: async (addresses) => {
+        const { BaseDb } = await Promise.resolve().then(function () { return BaseDb$1; });
+        if (!BaseDb) {
+            throw new Error('BaseDb not found');
+        }
+        if (!BaseDb.PlatformClass) {
+            await initDb();
+        }
+        const appDb = BaseDb.getAppDb();
+        if (!appDb) {
+            throw new Error('App DB not found');
+        }
+        appDb.insert(appState)
+            .values({
+            key: 'addresses',
+            value: JSON.stringify(addresses),
+        })
+            .onConflictDoUpdate({
+            target: appState.key,
+            set: {
+                value: JSON.stringify(addresses),
+            },
+        });
+    },
     subscribe: (callback) => {
         const subscription = globalService.subscribe(callback);
         eventEmitter.addListener('internal.globalService', callback);
@@ -7783,5 +8741,5 @@ const client = {
 
 enableMapSet();
 
-export { BaseItem as B, Db as D, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, BaseItemProperty as a, BaseDb as b, ImageSrc as c, Item$2 as d, ItemProperty$2 as e, useItem as f, useItemProperties as g, useCreateItem as h, useItemProperty as i, useDeleteItem as j, useGlobalServiceStatus as k, usePublishItem as l, usePersistedSnapshots as m, useServices as n, useService as o, getCorrectId as p, getGlobalService as q, eventEmitter as r, saveAppState as s, withSeed as t, useItems as u, client as v, waitForFile as w };
-//# sourceMappingURL=index-OxV3e-OY.js.map
+export { BaseItem as B, Db as D, FileManager as F, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, BaseItemProperty as a, BaseDb as b, ImageSrc as c, Item$2 as d, ItemProperty$2 as e, useItem as f, useItemProperties as g, useCreateItem as h, useItemProperty as i, useDeleteItem as j, useGlobalServiceStatus as k, usePublishItem as l, usePersistedSnapshots as m, useServices as n, useService as o, getCorrectId as p, getGlobalService as q, eventEmitter as r, client as s, useItems as u, withSeed as w };
+//# sourceMappingURL=index-D3Scq_ka.js.map