@seedprotocol/sdk 0.3.2 → 0.3.3

package/dist/{index-DJjmh3u9.js → index-D-O-gmXo.js}

@@ -2,7 +2,7 @@ import { immerable, produce, enableMapSet } from 'immer';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, setup, assign, waitFor, raise, createActor } from 'xstate';
-import { c 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 BROWSER_FS_TOP_DIR, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, j as DB_CREATING_SUCCESS, k as DB_VALIDATING_SUCCESS, l as DB_VALIDATING_WAIT, b as BaseFileManager, m as DB_MIGRATING_SUCCESS, n as DB_WAITING_FOR_FILES_RECEIVED, o as DbState, M as MachineIds, p as DB_MIGRATING_WAIT, q as ARWEAVE_HOST, I as INTERNAL_VALIDATING_INPUT_SUCCESS, 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_NAME_APP, v as DB_ON_SNAPSHOT, 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, H as CLIENT_NOT_INITIALIZED } from './constants-Bhl5dZpN.js';
+import { c as BaseFileManager, 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 BROWSER_FS_TOP_DIR, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, 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, o as DbState, M as MachineIds, p as DB_MIGRATING_WAIT, q as ARWEAVE_HOST, I as INTERNAL_VALIDATING_INPUT_SUCCESS, 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_NAME_APP, v as DB_ON_SNAPSHOT, 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-C-6Pg8FW.js';
 import debug from 'debug';
 import pluralize from 'pluralize';
 import { sqliteTable, int, text, unique, getTableConfig } from 'drizzle-orm/sqlite-core';
@@ -10,7 +10,6 @@ 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 'graphql-request';
 import { throttle, camelCase, startCase, orderBy } from 'lodash-es';
 import { createBrowserInspector } from '@statelyai/inspect';
@@ -129,7 +128,7 @@ var BaseDb$1 = /*#__PURE__*/Object.freeze({
     BaseDb: BaseDb
 });
 
-debug('app:item:service:actors:waitForDb');
+debug('seedSdk:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -295,7 +294,7 @@ const initialize$4 = fromCallback(({ sendBack, input: { context } }) => {
 
 const eventEmitter = new EventEmitter();
 
-const logger$p = debug('app:shared:helpers');
+const logger$o = debug('seedSdk:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
     return customAlphabet(alphanumeric, 10)();
@@ -350,12 +349,13 @@ const getDataTypeFromString = (data) => {
 };
 const convertTxIdToImageSrc = async (txId) => {
     const imageFilePath = `/files/images/${txId}`;
-    const fileExists = await fs.promises.exists(imageFilePath);
+    const fileExists = await BaseFileManager.pathExists(imageFilePath);
     if (!fileExists) {
-        logger$p(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$o(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
-    const uint = await fs.promises.readFile(imageFilePath);
+    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
+    const uint = new Uint8Array(buffer);
     const imageBlob = new Blob([uint]);
     return URL.createObjectURL(imageBlob);
 };
@@ -1234,7 +1234,7 @@ const getEnvironment = () => {
     return 'node';
 };
 
-const logger$o = debug('app:services:global:actors:initialize');
+const logger$n = debug('seedSdk:services:global:actors:initialize');
 const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints, arweaveDomain, addresses, } = context;
     if (!internalService) {
@@ -1253,12 +1253,12 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     const _initInternal = async () => {
         return new Promise((resolve) => {
             internalSubscription = internalService.subscribe((snapshot) => {
-                logger$o('[sdk] [internal] snapshot.value', snapshot.value);
+                logger$n('[sdk] [internal] snapshot.value', snapshot.value);
                 if (snapshot.value === 'ready') {
                     resolve();
                 }
             });
-            logger$o('[sdk] [internal] sending init');
+            logger$n('[sdk] [internal] sending init');
             internalService.send({
                 type: 'init',
                 endpoints,
@@ -1299,7 +1299,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
         await fetchSchemaUids();
     };
     _initFileSystem().then(() => {
-        logger$o('[global/actors] File system initialized');
+        logger$n('[global/actors] File system initialized');
     });
     _initInternal()
         .then(() => {
@@ -1309,7 +1309,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
         return _initEas();
     })
         .then(() => {
-        logger$o('[global/actors] Internal initialized');
+        logger$n('[global/actors] Internal initialized');
         sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
         internalSubscription?.unsubscribe();
     });
@@ -1322,7 +1322,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$n = debug('app:services:global:actors:getSchemaForModel');
+const logger$m = debug('seedSdk:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -1338,12 +1338,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$n('[service/actor] [getSchemaForModel] model:', model);
+    logger$m('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$m = debug('app:services:global:actors:addModelsToDb');
+const logger$l = debug('seedSdk:services:global:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models: models$1 } = context;
     const _addModelsToDb = async () => {
@@ -1351,7 +1351,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = await import('./seed.schema.config-DzDX8e7g.js');
+        const { models: SeedModels } = await import('./seed.schema.config-DmTl3a9U.js');
         const allModels = {
             ...SeedModels,
             ...models$1,
@@ -1359,7 +1359,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
         for (const [modelName, _] of Object.entries(allModels)) {
-            logger$m('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$l('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = await appDb
                 .select()
@@ -1369,7 +1369,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 await appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$m('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$l('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = await appDb
                     .select({
                     id: models.id,
@@ -1439,11 +1439,11 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$l = debug('app:services:db:actors:checkStatus');
+const logger$k = debug('seedSdk:services:db:actors:checkStatus');
 const checkStatus = fromCallback(({ sendBack, input: { context, event, } }) => {
     const { dbName, } = context;
     let { pathToDir, } = context;
-    logger$l('[db/actors] checkStatus context', context);
+    logger$k('[db/actors] checkStatus context', context);
     console.log('[db/actors] checkStatus context', context);
     console.log('[db/actors] checkStatus event', event);
     if (isBrowser()) {
@@ -1478,9 +1478,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context, event, } }) => {
     });
 });
 
-const logger$k = debug('app:services:db:actors:connectToDb');
+const logger$j = debug('seedSdk:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$k('[db/actors] connectToDb context', context);
+    logger$j('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     if (!pathToDir || !dbName) {
         throw new Error('pathToDir and dbName are required');
@@ -1491,6 +1491,12 @@ const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         isConnecting = true;
+        if (isBrowser()) {
+            await import('./Db-CRWMiKY9.js');
+        }
+        if (!isBrowser()) {
+            await import('./Db-G5dIgZv-.js');
+        }
         const dbId = await BaseDb.connectToDb(pathToDir, dbName);
         if (dbId) {
             sendBack({ type: DB_CREATING_SUCCESS, dbId, });
@@ -1514,7 +1520,7 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
         // If any of the necessary files don't exist, we wipe them all and recreate
         let exists = false;
         for (const path of pathsToCheck) {
-            exists = await fs.promises.exists(path);
+            exists = await BaseFileManager.pathExists(path);
             if (!exists) {
                 sendBack({
                     type: DB_VALIDATING_WAIT,
@@ -1533,1044 +1539,16 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const saveAppState$1 = 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;
-            }
-            nonTextCount++;
-            if (nonTextCount / view.length > threshold) {
-                return true; // More than threshold are non-text bytes
-            }
-        }
-        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();
-            }
-            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$1('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$j = debug('app:browser:helpers:FileManager');
-class FileManager extends BaseFileManager {
-    static async getContentUrlFromPath(path) {
-        const fileExists = await this.pathExists(path);
-        if (fileExists) {
-            const file = await this.readFile(path);
-            return URL.createObjectURL(file);
-        }
-    }
-    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$j('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
-            //   },
-            // )
-        });
-    }
-    static async saveFile(filePath, content) {
-        try {
-            // Get a handle to the OPFS root directory
-            const root = await navigator.storage.getDirectory();
-            // Split the file path into directory and file name
-            const pathParts = filePath.split('/');
-            const fileName = pathParts.pop();
-            if (!fileName)
-                throw new Error('Invalid file path');
-            // Traverse directories and create them if they don't exist
-            let currentDir = root;
-            for (const part of pathParts) {
-                if (part !== '') {
-                    currentDir = await currentDir.getDirectoryHandle(part, { create: true });
-                }
-            }
-            // Get the file handle and create the file if it doesn't exist
-            const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
-            // Create a writable stream and write the content
-            const writable = await fileHandle.createWritable();
-            if (typeof content === 'string' || content instanceof Uint8Array) {
-                await writable.write(content);
-            }
-            else if (content instanceof Blob) {
-                await writable.write(content);
-            }
-            else if (content instanceof ArrayBuffer) {
-                await writable.write(new Blob([content]));
-            }
-            else {
-                throw new Error('Unsupported content type');
-            }
-            await writable.close();
-            console.log(`File written successfully: ${filePath}`);
-        }
-        catch (error) {
-            console.error(`Error writing to OPFS: ${error.message}`);
-        }
-    }
-    static async readFile(filePath) {
-        try {
-            // Get a handle to the OPFS root directory
-            const root = await navigator.storage.getDirectory();
-            // Split the file path into directory and file name
-            const pathParts = filePath.split('/');
-            const fileName = pathParts.pop();
-            if (!fileName)
-                throw new Error('Invalid file path');
-            // Traverse directories to reach the target file
-            let currentDir = root;
-            for (const part of pathParts) {
-                if (part !== '') {
-                    currentDir = await currentDir.getDirectoryHandle(part, { create: false });
-                }
-            }
-            // Get the file handle
-            const fileHandle = await currentDir.getFileHandle(fileName, { create: false });
-            // Get the file and read it as an ArrayBuffer
-            return await fileHandle.getFile();
-        }
-        catch (error) {
-            console.error(`Error reading from OPFS: ${error.message}`);
-            throw error;
-        }
-    }
-    static async readFileAsBuffer(filePath) {
-        try {
-            // Get the file and read it as an ArrayBuffer
-            const file = await this.readFile(filePath);
-            const arrayBuffer = await file.arrayBuffer();
-            // Convert ArrayBuffer to Buffer
-            return Buffer.from(arrayBuffer);
-        }
-        catch (error) {
-            console.error(`Error reading from OPFS: ${error.message}`);
-            throw error;
-        }
-    }
-}
-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$i = debug('app:services:db:actors:migrate');
+const logger$i = debug('seedSdk:services:db:actors:migrate');
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dbId, dbName } = context;
     logger$i('[db/actors] migrate context', context);
     let journalExists = false;
     const _checkForFiles = async () => {
         const journalPath = `/${pathToDbDir}/meta/_journal.json`;
-        journalExists = await fs.promises.exists(journalPath);
+        journalExists = await BaseFileManager.pathExists(journalPath);
         if (!journalExists && isBrowser()) {
-            await FileManager.waitForFile(journalPath, 500, 60000);
+            await BaseFileManager.waitForFile(journalPath, 500, 60000);
         }
     };
     const _migrate = async () => {
@@ -2592,7 +1570,7 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-debug('app:services:db:actors:waitForFiles');
+debug('seedSdk:services:db:actors:waitForFiles');
 const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
     if (!isBrowser()) {
         sendBack({ type: DB_WAITING_FOR_FILES_RECEIVED });
@@ -2602,7 +1580,7 @@ const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
     const _waitForFiles = async () => {
         return new Promise((resolve) => {
             const interval = setInterval(async () => {
-                const journalExists = await fs.promises.exists(`${pathToDbDir}/meta/_journal.json`);
+                const journalExists = await BaseFileManager.pathExists(`${pathToDbDir}/meta/_journal.json`);
                 if (journalExists) {
                     clearInterval(interval);
                     resolve();
@@ -2616,7 +1594,7 @@ const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$h = debug('app:services:db:machine');
+const logger$h = debug('seedSdk:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -2802,6 +1780,12 @@ const prepareDb = fromCallback(({ sendBack, input: { context } }) => {
         throw new Error('filesDir is required');
     }
     const _prepareDb = async () => {
+        if (isBrowser()) {
+            await import('./Db-CRWMiKY9.js');
+        }
+        if (!isBrowser()) {
+            await import('./Db-G5dIgZv-.js');
+        }
         const appDb = await BaseDb.prepareDb(filesDir);
         if (appDb) {
             sendBack({ type: 'prepareDbSuccess' });
@@ -2812,7 +1796,7 @@ const prepareDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$g = debug('app:services:internal:helpers');
+const logger$g = debug('seedSdk:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -2857,6 +1841,7 @@ class FileDownloadManager {
             migrationNumber = match[1];
         }
         if (migrationNumber) {
+            const fs = await BaseFileManager.getFs();
             const filesInDir = await fs.promises.readdir(localDirPath);
             for (const file of filesInDir) {
                 if (file === filename) {
@@ -2875,10 +1860,12 @@ class FileDownloadManager {
             }
         }
         try {
+            const fs = await BaseFileManager.getFs();
             await fs.promises.writeFile(localFilePath, fileData);
             logger$g(`[downloadFile] Wrote file async to ${localFilePath}`);
         }
         catch (error) {
+            const fs = await BaseFileManager.getFs();
             fs.writeFileSync(localFilePath, fileData);
             logger$g(`[downloadFile] Wrote file sync to ${localFilePath}`);
         }
@@ -2953,6 +1940,7 @@ const fetchDirectory = async (url) => {
 const confirmFilesExist = async (filePaths) => {
     let everythingDownloaded = false;
     for (const filePath of filePaths) {
+        const fs = await BaseFileManager.getFs();
         everythingDownloaded = await fs.promises.exists(filePath);
     }
     if (!everythingDownloaded) {
@@ -3061,12 +2049,28 @@ const GET_TRANSACTION_TAGS = graphql(/* GraphQL */ `
   }
 `);
 
+const saveAppState$1 = 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-C0g0es2v.js')).ArweaveClient;
+        (await import('./ArweaveClient-COlwyYTF.js')).ArweaveClient;
     }
     if (!isBrowser()) {
-        (await import('./ArweaveClient-CzkBgiZY.js')).ArweaveClient;
+        (await import('./ArweaveClient-2RMCxfNZ.js')).ArweaveClient;
     }
 };
 let domain = 'arweave.net';
@@ -3109,7 +2113,7 @@ const setArweaveDomain = (newDomain) => {
     domain = newDomain;
 };
 
-const logger$f = debug('app:files:download');
+const logger$f = debug('seedSdk:files:download');
 const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
     if (!isBrowser()) {
         return;
@@ -3247,6 +2251,12 @@ const fsInitHandler = async (_) => {
         return;
     }
     try {
+        if (isBrowser()) {
+            await import('./FileManager-gKGTTa4s.js');
+        }
+        if (!isBrowser()) {
+            await import('./FileManager-BOixZyex.js');
+        }
         await BaseFileManager.initializeFileSystem();
         isInitialized = true;
         eventEmitter.emit('fs.init.response', { success: true });
@@ -3276,7 +2286,7 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$e = debug('app:internal:actors:configureFs');
+const logger$e = debug('seedSdk:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService, filesDir, } = context;
     logger$e('[internal/actors] [configureFs] Configuring FS');
@@ -3296,8 +2306,9 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
             });
         }
         const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`;
-        let journalExists = await fs.promises.exists(journalPath);
+        let journalExists = await BaseFileManager.pathExists(journalPath);
         if (!journalExists) {
+            const fs = await BaseFileManager.getFs();
             journalExists = fs.existsSync(journalPath);
         }
         if (journalExists) {
@@ -3335,7 +2346,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$d = debug('app:services:internal:actors:saveConfig');
+const logger$d = debug('seedSdk:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, addresses, arweaveDomain } = context;
     if (!endpoints) {
@@ -3408,7 +2419,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-debug('app:services:internal:actors:loadAppDb');
+debug('seedSdk:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -3435,7 +2446,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-debug('app:services:internal:actors:waitForFiles');
+debug('seedSdk:services:internal:actors:waitForFiles');
 const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
     if (!isBrowser()) {
         sendBack({ type: 'filesReceived' });
@@ -3446,7 +2457,7 @@ const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
     const _waitForFiles = async () => {
         return new Promise((resolve) => {
             const interval = setInterval(async () => {
-                const journalExists = await fs.promises.exists(`${filesDir}/db/meta/_journal.json`);
+                const journalExists = await BaseFileManager.pathExists(`${filesDir}/db/meta/_journal.json`);
                 if (journalExists) {
                     clearInterval(interval);
                     resolve();
@@ -3460,7 +2471,7 @@ const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$c = debug('app:services:internal:machine');
+const logger$c = debug('seedSdk:services:internal:machine');
 const { inspect: inspect$1 } = createBrowserInspector({
     autoStart: false,
 });
@@ -3803,7 +2814,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-debug('app:allItemsActors:fetchSeeds');
+debug('seedSdk:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -4262,7 +3273,7 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$b = debug('app:services:publish:actors:upload');
+const logger$b = debug('seedSdk:services:publish:actors:upload');
 const upload = fromCallback(({ sendBack, input: { context } }) => {
     const { localId } = context;
     const _upload = async () => {
@@ -5199,7 +4210,7 @@ const getSeedData = async ({ seedLocalId, seedUid }) => {
     return rows[0];
 };
 
-const logger$a = debug('app:db:read:getItemData');
+const logger$a = debug('seedSdk:db:read:getItemData');
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -5316,12 +4327,13 @@ const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) =>
     const storageTransactionId = propertyInstances.get('storageTransactionId');
     const _resolveRemoteStorage = async () => {
         const path = await import('path-browserify');
-        const filesDirExists = await fs.promises.exists('/files');
+        const filesDirExists = await BaseFileManager.pathExists('/files');
         if (!filesDirExists) {
-            await fs.promises.mkdir('/files');
+            await BaseFileManager.createDirIfNotExists('/files');
         }
         const htmlDir = path.join('/files', 'html');
-        const htmlExists = await fs.promises.exists(htmlDir);
+        const htmlExists = await BaseFileManager.pathExists(htmlDir);
+        const fs = await BaseFileManager.getFs();
         if (htmlExists) {
             const htmlFiles = await fs.promises.readdir(htmlDir);
             const matchingHtmlFile = htmlFiles.find((file) => file === `${storageTransactionId}.html`);
@@ -5361,7 +4373,7 @@ const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-debug('app:ItemProperty:service:actors:waitForDb');
+debug('seedSdk:ItemProperty:service:actors:waitForDb');
 const waitForDb = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -5400,12 +4412,11 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
         const _getContentsFromFileSystem = async () => {
             if (propertyName === 'html') {
                 const htmlFilePath = `/files/html/${storageTransactionId}.html`;
-                const exists = await fs.promises.exists(htmlFilePath);
+                const exists = await BaseFileManager.pathExists(htmlFilePath);
                 if (!exists) {
                     return;
                 }
-                const renderValue = await fs.promises
-                    .readFile(`/files/html/${storageTransactionId}.html`, 'utf8')
+                const renderValue = await BaseFileManager.readFileAsString(htmlFilePath)
                     .catch((error) => {
                     console.warn('Error reading html file', error);
                 });
@@ -5414,12 +4425,11 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
             }
             if (propertyName === 'json') {
                 const jsonFilePath = `/files/json/${storageTransactionId}.json`;
-                const exists = await fs.promises.exists(jsonFilePath);
+                const exists = await BaseFileManager.pathExists(jsonFilePath);
                 if (!exists) {
                     return;
                 }
-                const renderValue = await fs.promises
-                    .readFile(`/files/json/${storageTransactionId}.json`, 'utf8')
+                const renderValue = await BaseFileManager.readFileAsString(jsonFilePath)
                     .catch((error) => {
                     console.warn('Error reading json file', error);
                 });
@@ -5471,7 +4481,7 @@ const getRelationValueData = async (propertyValue) => {
     return rows[0];
 };
 
-const logger$9 = debug('app:property:actors:resolveRelatedValue');
+const logger$9 = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -5560,11 +4570,10 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                     });
                     return true;
                 }
-                const fileExists = await fs.promises.exists('/files/images/' + refResolvedValue);
+                const fileExists = await BaseFileManager.pathExists('/files/images/' + refResolvedValue);
                 if (fileExists) {
-                    const fileContents = await fs.promises.readFile('/files/images/' + refResolvedValue);
-                    const fileHandler = new File([fileContents], refResolvedValue);
-                    const contentUrl = URL.createObjectURL(fileHandler);
+                    const file = await BaseFileManager.readFile('/files/images/' + refResolvedValue);
+                    const contentUrl = URL.createObjectURL(file);
                     refResolvedValueToContentUrl.set(refResolvedValue, contentUrl);
                     sendBack({
                         type: 'updateContext',
@@ -5587,11 +4596,10 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                             storageTransactionIdToContentUrl.get(propertyValueFromDb);
                     }
                     if (!contentUrl) {
-                        const imageFileExists = await fs.promises.exists(`/images/${propertyValue}`);
+                        const imageFileExists = await BaseFileManager.pathExists(`/images/${propertyValue}`);
                         if (imageFileExists) {
-                            const fileContents = await fs.promises.readFile(`/images/${propertyValue}`);
-                            const fileHandler = new File([fileContents], propertyValue);
-                            contentUrl = URL.createObjectURL(fileHandler);
+                            const file = await BaseFileManager.readFile(`/images/${propertyValue}`);
+                            contentUrl = URL.createObjectURL(file);
                             storageTransactionIdToContentUrl.set(propertyValueFromDb, contentUrl);
                         }
                     }
@@ -5790,7 +4798,7 @@ const updateMetadata = async (metadataValues, propertyRecordSchema) => {
     await appDb.update(metadata).set(rest).where(eq(metadata.localId, localId));
 };
 
-debug('app:property:actors:hydrateFromDb');
+debug('seedSdk:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
     let propertyName = propertyNameRaw;
@@ -5897,6 +4905,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     }
                 }
                 const dirPath = `/files/${dir}`;
+                const fs = await BaseFileManager.getFs();
                 const files = await fs.promises.readdir(dirPath);
                 const matchingFiles = files.filter((file) => {
                     return path.basename(file).includes(refResolvedValue);
@@ -5910,9 +4919,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     filePath = `/files/${dir}/${filename}`;
                 }
                 if (fileExists && filename && filePath) {
-                    const fileContents = await fs.promises.readFile(filePath);
-                    const fileHandler = new File([fileContents], filename);
-                    refResolvedDisplayValue = URL.createObjectURL(fileHandler);
+                    const file = await BaseFileManager.readFile(filePath);
+                    refResolvedDisplayValue = URL.createObjectURL(file);
                     await updateMetadata({
                         localId,
                         refResolvedValue: filename,
@@ -5946,18 +4954,18 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await import('./index-DtB4Tlwd.js');
+            const { Item } = await import('./index-BxAVepOO.js');
             const item = await Item.find({
                 seedLocalId,
                 modelName,
             });
             if (item) {
                 const filePath = `/files/${localStorageDir}/${refResolvedValue}`;
-                const exists = await fs.promises.exists(filePath);
+                const exists = await BaseFileManager.pathExists(filePath);
                 if (!exists) {
                     return;
                 }
-                const renderValue = await fs.promises.readFile(filePath, 'utf8');
+                const renderValue = await BaseFileManager.readFileAsString(filePath);
                 const property = item.properties[propertyName];
                 property.getService().send({ type: 'updateContext', renderValue });
                 return;
@@ -5991,7 +4999,7 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$8 = debug('app:write:updateItemPropertyValue');
+const logger$8 = debug('seedSdk:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, }) => {
     if (!localId && !seedLocalId) {
         logger$8(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
@@ -6366,6 +5374,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 await BaseFileManager.saveFile(filePath, new Uint8Array(fileData));
             }
             catch (e) {
+                const fs = await BaseFileManager.getFs();
                 fs.writeFileSync(filePath, new Uint8Array(fileData));
                 eventEmitter.emit('file-saved', filePath);
             }
@@ -6375,6 +5384,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 await BaseFileManager.saveFile(filePath, fileData);
             }
             catch (e) {
+                const fs = await BaseFileManager.getFs();
                 fs.writeFileSync(filePath, fileData);
                 eventEmitter.emit('file-saved', filePath);
             }
@@ -6613,6 +5623,7 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
             await BaseFileManager.saveFile(filePath, newValue);
         }
         catch (error) {
+            const fs = await BaseFileManager.getFs();
             fs.writeFileSync(filePath, newValue);
         }
         await appDb
@@ -6846,7 +5857,7 @@ const getPropertyData$1 = async ({ propertyName, seedLocalId, seedUid, }) => {
 };
 
 var _a$1;
-const logger$7 = debug('app:property:class');
+const logger$7 = debug('seedSdk:property:class');
 class BaseItemProperty {
     constructor(initialValues) {
         this._isRelation = false;
@@ -6931,9 +5942,9 @@ class BaseItemProperty {
                 context.localStorageDir) {
                 const filePath = `/files/${context.localStorageDir}/${context.refResolvedValue}`;
                 try {
-                    const exists = await fs.promises.exists(filePath);
+                    const exists = await BaseFileManager.pathExists(filePath);
                     if (exists) {
-                        renderValue = await fs.promises.readFile(filePath, 'utf-8');
+                        renderValue = await BaseFileManager.readFileAsString(filePath);
                     }
                     if (!exists) {
                         renderValue = 'No file found';
@@ -7185,7 +6196,7 @@ const getSegmentedItemProperties = (item) => {
     };
 };
 
-const logger$6 = debug('app:item:getPublishUploads');
+const logger$6 = debug('seedSdk:item:getPublishUploads');
 const prepareArweaveTransaction = async (data, contentHash) => {
     const transactionData = {
         data,
@@ -7207,7 +6218,7 @@ const processUploadProperty = async (uploadProperty, uploads, relatedItemPropert
         if (!filePath || filePath.endsWith('undefined')) {
             continue;
         }
-        const exists = await fs.promises.exists(filePath);
+        const exists = await BaseFileManager.pathExists(filePath);
         if (!exists) {
             continue;
         }
@@ -7224,14 +6235,15 @@ const processUploadProperty = async (uploadProperty, uploads, relatedItemPropert
             if (!filePath || filePath.endsWith('undefined')) {
                 return uploads;
             }
-            const exists = await fs.promises.exists(filePath);
+            const exists = await BaseFileManager.pathExists(filePath);
             if (!exists) {
                 return uploads;
             }
             try {
-                fileContents = await fs.promises.readFile(filePath);
+                fileContents = await BaseFileManager.readFileAsString(filePath);
             }
             catch (e) {
+                const fs = await BaseFileManager.getFs();
                 fileContents = fs.readFileSync(filePath);
             }
         }
@@ -7892,31 +6904,10 @@ const initItem = async () => {
         Item$2 = (await Promise.resolve().then(function () { return Item$1; })).Item;
     }
     if (!isBrowser()) {
-        Item$2 = (await import('./Item-CUQ8wILT.js')).Item;
-    }
-};
-
-let ItemProperty$2;
-const initItemProperty = async () => {
-    if (isBrowser()) {
-        ItemProperty$2 = (await Promise.resolve().then(function () { return ItemProperty$1; })).ItemProperty;
-    }
-    if (!isBrowser()) {
-        ItemProperty$2 = (await import('./ItemProperty-DjGDsSEN.js')).ItemProperty;
+        Item$2 = (await import('./Item-BD2_tuda.js')).Item;
     }
 };
 
-let Db;
-const initDb = async () => {
-    if (isBrowser()) {
-        Db = (await import('./Db-DL9szGvt.js')).Db;
-    }
-    if (!isBrowser()) {
-        Db = (await import('./Db-Bn2_MKKq.js')).Db;
-    }
-    // TODO: Add config for React Native
-};
-
 class Item extends BaseItem {
     constructor(initialValues) {
         super(initialValues);
@@ -7929,7 +6920,7 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-const logger$5 = debug('app:react:services');
+const logger$5 = debug('seedSdk:react:services');
 const finalStrings = ['idle', 'ready', 'done', 'success', 'initialized'];
 const getServiceName = (service) => {
     let name = 'actor';
@@ -8064,7 +7055,7 @@ const usePersistedSnapshots = () => {
     const save = useCallback(async () => {
         for (const actor of services) {
             const uniqueKey = getServiceUniqueKey(actor);
-            console.log(`would save to db with snapshot__${uniqueKey}:`, JSON.stringify(actor.getPersistedSnapshot()));
+            logger$5(`would save to db with snapshot__${uniqueKey}:`, JSON.stringify(actor.getPersistedSnapshot()));
             // await writeAppState(
             //   `snapshot__${uniqueKey}`,
             //   JSON.stringify(actor.getPersistedSnapshot()),
@@ -8205,7 +7196,7 @@ const useGlobalServiceStatus = () => {
     };
 };
 
-const logger$4 = debug('app:react:item');
+const logger$4 = debug('seedSdk:react:item');
 const useItem = ({ modelName, seedLocalId, seedUid }) => {
     // const [itemSubscription, setItemSubscription] = useState<
     //   Subscription | undefined
@@ -8463,7 +7454,7 @@ var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     ItemProperty: ItemProperty
 });
 
-const logger$3 = debug('app:react:property');
+const logger$3 = debug('seedSdk:react:property');
 const useItemProperty = (props = {
     propertyName: '',
     seedLocalId: '',
@@ -8560,7 +7551,7 @@ const useItemProperties = (item) => {
     };
 };
 
-debug('app:react:db');
+debug('seedSdk:react:db');
 
 const deleteItem = async ({ seedLocalId, seedUid }) => {
     const appDb = BaseDb.getAppDb();
@@ -8659,32 +7650,32 @@ const withSeed = (config, webpack, isServer) => {
 
 const initEasClient = async () => {
     if (isBrowser()) {
-        (await import('./EasClient-B9a3NsTi.js')).EasClient;
+        (await import('./EasClient-CO5puCWa.js')).EasClient;
     }
     if (!isBrowser()) {
-        (await import('./EasClient-DQ93i2ci.js')).EasClient;
+        (await import('./EasClient-CFnb5g-r.js')).EasClient;
     }
 };
 
-const initFileManager = async () => {
+const initQueryClient = async () => {
     if (isBrowser()) {
-        (await Promise.resolve().then(function () { return FileManager$1; })).FileManager;
+        (await import('./QueryClient-W4slRa7O.js')).QueryClient;
     }
     if (!isBrowser()) {
-        (await import('./FileManager-Gci1k5HJ.js')).FileManager;
+        (await import('./QueryClient-ZUsZ1Qxq.js')).QueryClient;
     }
 };
 
-const initQueryClient = async () => {
+const initItemProperty = async () => {
     if (isBrowser()) {
-        (await import('./QueryClient-hzOtFe99.js')).QueryClient;
+        (await Promise.resolve().then(function () { return ItemProperty$1; })).ItemProperty;
     }
     if (!isBrowser()) {
-        (await import('./QueryClient-Bmnv_moN.js')).QueryClient;
+        (await import('./ItemProperty-CjcrzEmg.js')).ItemProperty;
     }
 };
 
-const logger$2 = debug('app:services:events');
+const logger$2 = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
     logger$2(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
@@ -8713,7 +7704,8 @@ const setupServiceHandlers = () => {
     eventEmitter.addListener('service.save', saveServiceHandler);
 };
 
-const logger$1 = debug('app:ClientManager:initialize');
+// import { initDb } from "@/db/Db";
+const logger$1 = debug('seedSdk:ClientManager:initialize');
 const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
     logger$1('initialize from ClientManager');
     const { isInitialized } = context;
@@ -8729,8 +7721,7 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
         await initEasClient();
         await initArweaveClient();
         await initQueryClient();
-        await initFileManager();
-        await initDb();
+        // await initDb()
         const { models, endpoints, arweaveDomain, } = config;
         const { files } = endpoints;
         if (arweaveDomain) {
@@ -8758,7 +7749,7 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
             arweaveDomain,
             filesDir: files,
         });
-        const { models: internalModels } = await import('./seed.schema.config-DzDX8e7g.js');
+        const { models: internalModels } = await import('./seed.schema.config-DmTl3a9U.js');
         for (const [key, value] of Object.entries(internalModels)) {
             setModel(key, value);
         }
@@ -8773,7 +7764,7 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
     });
 });
 
-debug('app:client:writeToDb');
+debug('seedSdk:client:writeToDb');
 const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         const { BaseDb } = await Promise.resolve().then(function () { return BaseDb$1; });
@@ -8875,29 +7866,34 @@ const clientManagerMachine = setup({
     },
 });
 
-const logger = debug('app:client');
+// import { SeedConstructorOptions } from '@/types/index'
+// import { BaseDb }                 from '@/db/Db/BaseDb'
+// import { appState }               from '@/seedSchema'
+// import { eq }                     from 'drizzle-orm'
+// import { CLIENT_NOT_INITIALIZED } from '@/helpers/constants'
+const logger = debug('seedSdk:client');
 const clientManager = createActor(clientManagerMachine, {
     input: {
         isInitialized: false,
     }
 });
-const subscription = clientManager.subscribe((snapshot) => {
+clientManager.subscribe((snapshot) => {
     logger('ClientManager snapshot.value:', snapshot.value);
     logger('ClientManager snapshot.context.isInitialized:', snapshot.context.isInitialized);
 });
 clientManager.start();
-const ensureInitialized = () => {
-    if (!clientManager.getSnapshot().context.isInitialized) {
-        throw new Error(CLIENT_NOT_INITIALIZED);
-    }
-};
+// const ensureInitialized = () => {
+//   if (!clientManager.getSnapshot().context.isInitialized) {
+//     throw new Error(CLIENT_NOT_INITIALIZED);
+//   }
+// }
 const ClientManager = {
     isInitialized: () => {
         return clientManager.getSnapshot().context.isInitialized;
     },
     getService: () => {
-        ensureInitialized();
-        return clientManager;
+        // ensureInitialized();
+        // return clientManager;
     },
     // init: async (options: SeedConstructorOptions) => {
     init: async (options) => {
@@ -8905,30 +7901,30 @@ const ClientManager = {
         await waitFor(clientManager, (snapshot) => snapshot.context.isInitialized);
     },
     setAddresses: async (addresses) => {
-        ensureInitialized();
-        logger('setAddresses', addresses);
-        clientManager.send({ type: 'setAddresses', addresses });
-        await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving);
-        logger('setAddresses success', addresses);
+        // ensureInitialized();
+        // logger('setAddresses', addresses);
+        // clientManager.send({ type: 'setAddresses', addresses });
+        // await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving);
+        // logger('setAddresses success', addresses);
     },
     getAddresses: async () => {
-        ensureInitialized();
-        const db = await BaseDb.getAppDb();
-        const results = await db.select().from(appState).where(eq(appState.key, 'addresses'));
-        return JSON.parse(results[0]?.value);
+        // ensureInitialized();
+        // const db = await BaseDb.getAppDb();
+        // const results = await db.select().from(appState).where(eq(appState.key, 'addresses'));
+        // return JSON.parse(results[0]?.value);
     },
     stop: () => {
-        ensureInitialized();
-        clientManager.stop();
+        // ensureInitialized();
+        // clientManager.stop();
     },
     unload: () => {
-        ensureInitialized();
-        clientManager.stop();
-        subscription.unsubscribe();
+        // ensureInitialized();
+        // clientManager.stop();
+        // subscription.unsubscribe();
     },
 };
 
 enableMapSet();
 
-export { BaseItem as B, ClientManager as C, 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, appState as c, ImageSrc as d, Item$2 as e, ItemProperty$2 as f, useItem as g, useItemProperties as h, isBrowser as i, useCreateItem as j, useItemProperty as k, useDeleteItem as l, useGlobalServiceStatus as m, usePublishItem as n, usePersistedSnapshots as o, useServices as p, useService as q, getCorrectId as r, getGlobalService as s, eventEmitter as t, useItems as u, withSeed as w };
-//# sourceMappingURL=index-DJjmh3u9.js.map
+export { BaseItem as B, ClientManager as C, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, BaseDb as a, appState as b, BaseItemProperty as c, ImageSrc as d, Item$2 as e, useItem as f, useItemProperties as g, useCreateItem as h, isBrowser as i, useItemProperty as j, useDeleteItem as k, useGlobalServiceStatus as l, usePublishItem as m, usePersistedSnapshots as n, useServices as o, useService as p, getCorrectId as q, eventEmitter as r, saveAppState$1 as s, useItems as u, withSeed as w };
+//# sourceMappingURL=index-D-O-gmXo.js.map