@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/{index-CTZqN6WI.js → index-BSR5hv7Q.js}

@@ -1,16 +1,17 @@
 import { immerable, produce, enableMapSet } from 'immer';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
-import { fromCallback, setup, assign, waitFor, createActor, raise } 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 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, b 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-CIDbABDz.js';
+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 debug from 'debug';
 import pluralize from 'pluralize';
-import { sqliteTable, text, int, unique } from 'drizzle-orm/sqlite-core';
-import { relations, or, and, isNotNull, not, eq, inArray, sql, like, getTableColumns, isNull, count, max, gt } from 'drizzle-orm';
+import { sqliteTable, int, text, unique, getTableConfig } from 'drizzle-orm/sqlite-core';
+import { relations, or, and, isNotNull, not, eq, inArray, sql, like, getTableColumns, isNull, max, count, gt } from 'drizzle-orm';
 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';
 import path from 'path';
@@ -294,7 +295,7 @@ const initialize$4 = fromCallback(({ sendBack, input: { context } }) => {
 
 const eventEmitter = new EventEmitter();
 
-const logger$s = debug('app:shared:helpers');
+const logger$p = debug('app:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
     return customAlphabet(alphanumeric, 10)();
@@ -351,7 +352,7 @@ const convertTxIdToImageSrc = async (txId) => {
     const imageFilePath = `/files/images/${txId}`;
     const fileExists = await fs.promises.exists(imageFilePath);
     if (!fileExists) {
-        logger$s(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$p(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
     const uint = await fs.promises.readFile(imageFilePath);
@@ -1032,7 +1033,7 @@ const saveEasPropertiesToDb = async ({ itemProperties, itemSeeds, }) => {
                 isList = true;
                 refValueType = 'list';
                 const result = parseEasRelationPropertyName(propertyNameSnake);
-                {
+                if (result) {
                     propertyNameSnake = result.propertyName;
                     refSeedType = result.modelName;
                 }
@@ -1198,7 +1199,7 @@ const syncDbWithEasHandler = throttle(async (_) => {
             },
         }),
     });
-    saveEasPropertiesToDb({
+    const { propertyUids } = saveEasPropertiesToDb({
         itemProperties,
         itemSeeds,
     });
@@ -1233,7 +1234,7 @@ const getEnvironment = () => {
     return 'node';
 };
 
-const logger$r = debug('app:services:global:actors:initialize');
+const logger$o = debug('app:services:global:actors:initialize');
 const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints, arweaveDomain, addresses, } = context;
     if (!internalService) {
@@ -1252,11 +1253,12 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     const _initInternal = async () => {
         return new Promise((resolve) => {
             internalSubscription = internalService.subscribe((snapshot) => {
-                logger$r('[sdk] [internal] snapshot', snapshot);
+                logger$o('[sdk] [internal] snapshot.value', snapshot.value);
                 if (snapshot.value === 'ready') {
                     resolve();
                 }
             });
+            logger$o('[sdk] [internal] sending init');
             internalService.send({
                 type: 'init',
                 endpoints,
@@ -1297,7 +1299,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
         await fetchSchemaUids();
     };
     _initFileSystem().then(() => {
-        logger$r('[global/actors] File system initialized');
+        logger$o('[global/actors] File system initialized');
     });
     _initInternal()
         .then(() => {
@@ -1307,7 +1309,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
         return _initEas();
     })
         .then(() => {
-        logger$r('[global/actors] Internal initialized');
+        logger$o('[global/actors] Internal initialized');
         sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
         internalSubscription?.unsubscribe();
     });
@@ -1320,7 +1322,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$q = debug('app:services:global:actors:getSchemaForModel');
+const logger$n = debug('app:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -1336,12 +1338,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$q('[service/actor] [getSchemaForModel] model:', model);
+    logger$n('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$p = debug('app:services:global:actors:addModelsToDb');
+const logger$m = debug('app:services:global:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models: models$1 } = context;
     const _addModelsToDb = async () => {
@@ -1349,7 +1351,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = await import('./seed.schema.config-B-4U2RRq.js');
+        const { models: SeedModels } = await import('./seed.schema.config-BxJYabim.js');
         const allModels = {
             ...SeedModels,
             ...models$1,
@@ -1357,7 +1359,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
         for (const [modelName, _] of Object.entries(allModels)) {
-            logger$p('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$m('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = await appDb
                 .select()
@@ -1367,7 +1369,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 await appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$p('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$m('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = await appDb
                     .select({
                     id: models.id,
@@ -1437,11 +1439,16 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$o = debug('app:services:db:actors:checkStatus');
-const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
-    const { dbName } = context;
-    logger$o('[db/actors] checkStatus context', context);
-    const pathToDir = `${BROWSER_FS_TOP_DIR}`;
+const logger$l = debug('app:services:db:actors:checkStatus');
+const checkStatus = fromCallback(({ sendBack, input: { context, event, } }) => {
+    const { dbName, } = context;
+    let { pathToDir, } = context;
+    logger$l('[db/actors] checkStatus context', context);
+    console.log('[db/actors] checkStatus context', context);
+    console.log('[db/actors] checkStatus event', event);
+    if (isBrowser()) {
+        pathToDir = BROWSER_FS_TOP_DIR;
+    }
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
     sendBack({
@@ -1471,9 +1478,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$n = debug('app:services:db:actors:connectToDb');
+const logger$k = debug('app:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$n('[db/actors] connectToDb context', context);
+    logger$k('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     if (!pathToDir || !dbName) {
         throw new Error('pathToDir and dbName are required');
@@ -2256,20 +2263,13 @@ class ImageResizer {
     }
 }
 
-const logger$m = debug('app:browser:helpers:FileManager');
+const logger$j = 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);
+        const fileExists = await this.pathExists(path);
         if (fileExists) {
-            const fileContents = await fs.promises.readFile(path);
-            const fileHandler = new File([fileContents], path);
-            return URL.createObjectURL(fileHandler);
+            const file = await this.readFile(path);
+            return URL.createObjectURL(file);
         }
     }
     static async initializeFileSystem() {
@@ -2362,7 +2362,7 @@ class FileManager extends BaseFileManager {
             const startTime = Date.now();
             let isBusy = false;
             const cancelableInterval = new CancelableInterval(async (stop) => {
-                logger$m('waitForFile', filePath);
+                logger$j('waitForFile', filePath);
                 if (isBusy) {
                     return;
                 }
@@ -2449,7 +2449,7 @@ class FileManager extends BaseFileManager {
             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') {
+            if (typeof content === 'string' || content instanceof Uint8Array) {
                 await writable.write(content);
             }
             else if (content instanceof Blob) {
@@ -2468,6 +2468,45 @@ class FileManager extends BaseFileManager {
             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 {
@@ -2522,15 +2561,15 @@ var FileManager$1 = /*#__PURE__*/Object.freeze({
     FileManager: FileManager
 });
 
-const logger$l = debug('app:services:db:actors:migrate');
+const logger$i = debug('app:services:db:actors:migrate');
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dbId, dbName } = context;
-    logger$l('[db/actors] migrate context', 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);
-        if (!journalExists) {
+        if (!journalExists && isBrowser()) {
             await FileManager.waitForFile(journalPath, 500, 60000);
         }
     };
@@ -2539,11 +2578,15 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     };
     _checkForFiles()
         .then(() => {
+        if (!isBrowser()) {
+            return _migrate();
+        }
         if (journalExists) {
             return _migrate();
         }
     })
         .then(() => {
+        console.log('sending db migrating success');
         sendBack({ type: DB_MIGRATING_SUCCESS, dbName });
     });
     return () => { };
@@ -2551,6 +2594,10 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
 
 debug('app:services:db:actors:waitForFiles');
 const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
+    if (!isBrowser()) {
+        sendBack({ type: DB_WAITING_FOR_FILES_RECEIVED });
+        return;
+    }
     const { pathToDbDir } = context;
     const _waitForFiles = async () => {
         return new Promise((resolve) => {
@@ -2569,7 +2616,7 @@ const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$k = debug('app:services:db:machine');
+const logger$h = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -2591,7 +2638,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$k('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$h('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -2600,8 +2647,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$k('[db/machine] updateHasFiles event:', event);
-                    logger$k('[db/machine] updateHasFiles context:', context);
+                    logger$h('[db/machine] updateHasFiles event:', event);
+                    logger$h('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -2755,9 +2802,9 @@ const prepareDb = fromCallback(({ sendBack, input: { context } }) => {
         throw new Error('filesDir is required');
     }
     const _prepareDb = async () => {
-        const manager = await BaseDb.prepareDb(filesDir);
-        if (manager) {
-            sendBack({ type: 'prepareDbSuccess', manager });
+        const appDb = await BaseDb.prepareDb(filesDir);
+        if (appDb) {
+            sendBack({ type: 'prepareDbSuccess' });
         }
     };
     _prepareDb().then(() => {
@@ -2765,7 +2812,7 @@ const prepareDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$j = debug('app:services:internal:helpers');
+const logger$g = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -2829,11 +2876,11 @@ class FileDownloadManager {
         }
         try {
             await fs.promises.writeFile(localFilePath, fileData);
-            logger$j(`[downloadFile] Wrote file async to ${localFilePath}`);
+            logger$g(`[downloadFile] Wrote file async to ${localFilePath}`);
         }
         catch (error) {
             fs.writeFileSync(localFilePath, fileData);
-            logger$j(`[downloadFile] Wrote file sync to ${localFilePath}`);
+            logger$g(`[downloadFile] Wrote file sync to ${localFilePath}`);
         }
     }
     async start() {
@@ -2923,7 +2970,7 @@ const syncDbFiles = async ({ filePaths, files }) => {
     await downloadManager.start();
     // await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList)
     await confirmFilesExist(fileList);
-    logger$j('[syncDbFiles] Files synced!');
+    logger$g('[syncDbFiles] Files synced!');
 };
 
 const GET_FILES_METADATA = graphql(/* GraphQL */ `
@@ -2973,7 +3020,7 @@ graphql(/* GraphQL */ `
 const getMetadata = async (props) => {
     const appDb = BaseDb.getAppDb();
     let storageTransactionId;
-    {
+    if (props) {
         storageTransactionId = props.storageTransactionId;
     }
     const whereClauses = [];
@@ -3016,10 +3063,10 @@ const GET_TRANSACTION_TAGS = graphql(/* GraphQL */ `
 
 const initArweaveClient = async () => {
     if (isBrowser()) {
-        (await import('./ArweaveClient-D5iJisYr.js')).ArweaveClient;
+        (await import('./ArweaveClient-C0g0es2v.js')).ArweaveClient;
     }
     if (!isBrowser()) {
-        (await import('./ArweaveClient-HEIIuOfB.js')).ArweaveClient;
+        (await import('./ArweaveClient-CzkBgiZY.js')).ArweaveClient;
     }
 };
 let domain = 'arweave.net';
@@ -3062,8 +3109,11 @@ const setArweaveDomain = (newDomain) => {
     domain = newDomain;
 };
 
-const logger$i = debug('app:files:download');
+const logger$f = debug('app:files:download');
 const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
+    if (!isBrowser()) {
+        return;
+    }
     await syncDbFiles(endpoints);
     eventEmitter.emit('fs.downloadAll.success', { eventId });
     eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
@@ -3146,7 +3196,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
         try {
             const res = await fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
             if (res.status !== 200) {
-                logger$i(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$f(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 await saveAppState$1('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -3175,7 +3225,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
             transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
-            logger$i(error);
+            logger$f(error);
         }
     }
     console.log('[download] Calling downloadAllFiles with transactionIdsToDownload', transactionIdsToDownload);
@@ -3226,23 +3276,25 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$h = debug('app:internal:actors:configureFs');
+const logger$e = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService, filesDir, } = context;
-    logger$h('[internal/actors] [configureFs] Configuring FS');
+    logger$e('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = async () => {
-        logger$h('[internal/actors] [configureFs] calling _configureFs');
-        logger$h('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$h('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
-        await waitForEvent({
-            req: {
-                eventLabel: 'fs.downloadAll.request',
-                data: { endpoints },
-            },
-            res: {
-                eventLabel: 'fs.downloadAll.success',
-            },
-        });
+        logger$e('[internal/actors] [configureFs] calling _configureFs');
+        logger$e('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$e('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        if (isBrowser()) {
+            await waitForEvent({
+                req: {
+                    eventLabel: 'fs.downloadAll.request',
+                    data: { endpoints },
+                },
+                res: {
+                    eventLabel: 'fs.downloadAll.success',
+                },
+            });
+        }
         const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`;
         let journalExists = await fs.promises.exists(journalPath);
         if (!journalExists) {
@@ -3250,7 +3302,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
         }
         if (journalExists) {
             appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED });
-            logger$h('[internal/actors] [configureFs] fs configured!');
+            logger$e('[internal/actors] [configureFs] fs configured!');
             return true;
         }
         sendBack({ type: 'shouldWaitForFiles' });
@@ -3283,15 +3335,8 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$g = debug('app:services:internal:actors:saveConfig');
+const logger$d = debug('app:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
-    if (typeof window === 'undefined') {
-        console.error('seedInitBrowser called from non-browser context');
-        sendBack({
-            type: 'error',
-            error: 'Browser method called from non-browser context',
-        });
-    }
     const { endpoints, addresses, arweaveDomain } = context;
     if (!endpoints) {
         throw new Error('saveConfig called with invalid endpoints');
@@ -3304,81 +3349,84 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
         }
         const endpointsValueString = JSON.stringify(endpoints);
         const addressesValueString = JSON.stringify(addresses);
+        const tableColumns = getTableColumns(appState);
+        logger$d('tableColumns', tableColumns);
+        const { columns, indexes, foreignKeys, checks, primaryKeys, name, } = getTableConfig(appState);
+        logger$d('columns', columns);
+        logger$d('indexes', indexes);
+        logger$d('foreignKeys', foreignKeys);
+        logger$d('checks', checks);
+        logger$d('primaryKeys', primaryKeys);
+        logger$d('name', name);
+        logger$d('calling select on db');
+        const queryResult = await appDb.select().from(appState);
+        logger$d('queryResult', queryResult);
         // TODO: Figure out how to define on conflict with multiple rows added
-        try {
-            // logger('[sdk] [internal/actors] Saving endpoints to db')
-            await appDb
-                .insert(appState)
-                .values({
-                key: 'endpoints',
+        await appDb
+            .insert(appState)
+            .values({
+            key: 'endpoints',
+            value: endpointsValueString,
+        })
+            .onConflictDoUpdate({
+            target: appState.key,
+            set: {
                 value: endpointsValueString,
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: endpointsValueString,
-                },
-            });
-            // logger('[sdk] [internal/actors] Saving addresses to db')
-            await appDb
-                .insert(appState)
-                .values({
-                key: 'addresses',
+            },
+        });
+        // logger('[sdk] [internal/actors] Saving addresses to db')
+        await appDb
+            .insert(appState)
+            .values({
+            key: 'addresses',
+            value: addressesValueString,
+        })
+            .onConflictDoUpdate({
+            target: appState.key,
+            set: {
                 value: addressesValueString,
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: addressesValueString,
-                },
-            });
-            await appDb
-                .insert(appState)
-                .values({
-                key: 'arweaveDomain',
+            },
+        });
+        await appDb
+            .insert(appState)
+            .values({
+            key: 'arweaveDomain',
+            value: arweaveDomain || 'arweave.net',
+        })
+            .onConflictDoUpdate({
+            target: appState.key,
+            set: {
                 value: arweaveDomain || 'arweave.net',
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: arweaveDomain || 'arweave.net',
-                },
-            });
-            logger$g('[sdk] [internal/actors] Should be done saving');
-        }
-        catch (error) {
-            console.error('Error saving config:', error);
-        }
+            },
+        });
+        logger$d('[sdk] [internal/actors] Should be done saving');
     };
     _saveConfig().then(() => {
-        logger$g('[sdk] [internal/actors] Successfully saved config');
+        logger$d('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$f = debug('app:services:internal:actors:loadAppDb');
+debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
     const _loadAppDb = async () => {
+        if (appDbService.getSnapshot().value === 'ready') {
+            return;
+        }
         return new Promise((resolve) => {
-            if (appDbService.getSnapshot().value === 'ready') {
-                return resolve();
-            }
-            subscription = appDbService.subscribe({
-                next: (snapshot) => {
-                    if (snapshot.value === 'ready') {
-                        return resolve();
-                    }
-                    sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot });
-                },
+            subscription = appDbService.subscribe((snapshot) => {
+                if (snapshot.value === 'ready') {
+                    return resolve();
+                }
+                sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot });
             });
         });
     };
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$f('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -3389,6 +3437,10 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
 
 debug('app:services:internal:actors:waitForFiles');
 const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
+    if (!isBrowser()) {
+        sendBack({ type: 'filesReceived' });
+        return;
+    }
     const { endpoints } = context;
     const filesDir = endpoints.files;
     const _waitForFiles = async () => {
@@ -3408,8 +3460,8 @@ const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$e = debug('app:services:internal:machine');
-createBrowserInspector({
+const logger$c = debug('app:services:internal:machine');
+const { inspect: inspect$1 } = createBrowserInspector({
     autoStart: false,
 });
 const { IDLE: IDLE$1, VALIDATING_INPUT, SAVING_CONFIG, CONFIGURING_FS, LOADING_APP_DB, } = InternalState;
@@ -3445,11 +3497,14 @@ const internalMachine = setup({
                     target: VALIDATING_INPUT,
                     actions: [
                         assign({
-                            appDbService: ({ spawn }) => spawn(dbMachine, {
-                                input: {
-                                    dbName: DB_NAME_APP,
-                                },
-                            }),
+                            appDbService: ({ context, spawn }) => {
+                                return spawn(dbMachine, {
+                                    input: {
+                                        dbName: DB_NAME_APP,
+                                        pathToDir: context?.filesDir,
+                                    },
+                                });
+                            },
                         }),
                     ],
                 },
@@ -3528,7 +3583,7 @@ const internalMachine = setup({
                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                     target: SAVING_CONFIG,
                     actions: () => {
-                        logger$e('[sdk] [internal/index] App DB loaded!');
+                        logger$c('[sdk] [internal/index] App DB loaded!');
                     },
                 },
             },
@@ -3554,7 +3609,8 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$e('[sdk] [internal/index] Ready!');
+                console.log('[sdk] [internal/index] Ready!');
+                logger$c('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -3569,7 +3625,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$e('[sdk] [internal/index] Error!');
+                logger$c('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -3739,6 +3795,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { context } }) => {
 });
 
 const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
+    const { modelNamePlural, times } = context;
     const _fetchDbData = async () => { };
     _fetchDbData().then(() => {
         sendBack({ type: 'fetchDbDataSuccess' });
@@ -3746,7 +3803,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$d = debug('app:allItemsActors:fetchSeeds');
+debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -3757,8 +3814,6 @@ const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
         const queryKey = [`getSeeds${modelName}`];
         const queryClient = BaseQueryClient.getQueryClient();
         const easClient = BaseEasClient.getEasClient();
-        const cachedResults = queryClient.getQueryData(queryKey);
-        logger$d(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
         const results = await queryClient.fetchQuery({
             queryKey,
             queryFn: async () => easClient.request(GET_SEEDS, queryVariables),
@@ -4173,7 +4228,7 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
         }
         const versionSchemaUid = modelsRows[0].schemaUid;
         await item.getEditedProperties();
-        await getModelSchemas();
+        const { modelSchemas, schemaStringToModelRecord } = await getModelSchemas();
         // const dataEncoder = new SchemaEncoder(modelProperty.schemaDefinition,)
         // const encodedData = dataEncoder.encodeData(data,)
         //
@@ -4207,13 +4262,13 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$c = debug('app:services:publish:actors:upload');
+const logger$b = debug('app:services:publish:actors:upload');
 const upload = fromCallback(({ sendBack, input: { context } }) => {
     const { localId } = context;
     const _upload = async () => {
         const item = await BaseItem.find({ seedLocalId: localId });
         if (!item) {
-            logger$c('no item with localId', localId);
+            logger$b('no item with localId', localId);
             return false;
         }
         const editedProperties = await item.getEditedProperties();
@@ -4231,7 +4286,7 @@ const upload = fromCallback(({ sendBack, input: { context } }) => {
                 editedProperty.propertyDef.refValueType === 'ImageSrc') {
                 const context = editedProperty.getService().getSnapshot().context;
                 const imageSeedId = context.propertyValue;
-                getCorrectId(imageSeedId);
+                const { localId, uid } = getCorrectId(imageSeedId);
             }
             if (editedProperty.propertyDef.storageType === 'ItemStorage' &&
                 editedProperty.propertyDef.localStorageDir) ;
@@ -4334,7 +4389,7 @@ const savePublishService = fromCallback(({ sendBack, input: { event, context } }
 });
 
 const { UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
-createBrowserInspector({
+const { inspect } = createBrowserInspector({
     autoStart: false,
 });
 const globalMachine = setup({
@@ -5144,7 +5199,7 @@ const getSeedData = async ({ seedLocalId, seedUid }) => {
     return rows[0];
 };
 
-const logger$b = debug('app:db:read:getItemData');
+const logger$a = debug('app:db:read:getItemData');
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -5152,7 +5207,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$b('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$a('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -5187,7 +5242,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
         .groupBy(seeds.localId);
     if (!itemDataRows || itemDataRows.length === 0) {
-        logger$b('[db/queries] [getItemDataFromDb] no itemDataRows');
+        logger$a('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -5416,7 +5471,7 @@ const getRelationValueData = async (propertyValue) => {
     return rows[0];
 };
 
-const logger$a = debug('app:property:actors:resolveRelatedValue');
+const logger$9 = debug('app:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -5431,7 +5486,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             parsedValue = JSON.parse(propertyValue);
         }
         catch (error) {
-            logger$a(`${propertyName} value is not a JSON string.`);
+            logger$9(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(propertyValue)) {
             const contentUrl = seedUidToContentUrl.get(propertyValue);
@@ -5447,11 +5502,11 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$a(`${propertyName} value is an array of seedUids`);
+            logger$9(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (Array.isArray(parsedValue)) {
-            logger$a(`${propertyName} value is a stringified array of seedUids`);
+            logger$9(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(propertyValue);
@@ -5891,7 +5946,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await import('./index-DQNTvzqi.js');
+            const { Item } = await import('./index-BAtjd9W-.js');
             const item = await Item.find({
                 seedLocalId,
                 modelName,
@@ -5936,10 +5991,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$9 = debug('app:write:updateItemPropertyValue');
+const logger$8 = debug('app:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, }) => {
     if (!localId && !seedLocalId) {
-        logger$9(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$8(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -5977,7 +6032,7 @@ const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUi
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$9(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$8(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
             return;
         }
         // This means we already have a local-only record so we should just update that one
@@ -6363,11 +6418,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 refSeedType: 'image',
                 refResolvedDisplayValue,
                 refResolvedValue: fileName,
-                refModelUid: imageSchemaUid,
-                refSchemaUid: imageSchemaUid,
-                localStorageDir: '/images',
-                easDataType: 'bytes32',
-            });
+                localStorageDir: '/images'});
         }
         sendBack({
             type: 'updateContext',
@@ -6795,7 +6846,7 @@ const getPropertyData$1 = async ({ propertyName, seedLocalId, seedUid, }) => {
 };
 
 var _a$1;
-const logger$8 = debug('app:property:class');
+const logger$7 = debug('app:property:class');
 class BaseItemProperty {
     constructor(initialValues) {
         this._isRelation = false;
@@ -6842,7 +6893,7 @@ class BaseItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$8('List property value is not JSON', e);
+                            logger$7('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -6889,7 +6940,7 @@ class BaseItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$8(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$7(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = 'No file found';
                 }
             }
@@ -7134,7 +7185,7 @@ const getSegmentedItemProperties = (item) => {
     };
 };
 
-const logger$7 = debug('app:item:getPublishUploads');
+const logger$6 = debug('app:item:getPublishUploads');
 const prepareArweaveTransaction = async (data, contentHash) => {
     const transactionData = {
         data,
@@ -7142,8 +7193,8 @@ const prepareArweaveTransaction = async (data, contentHash) => {
     };
     const tx = await getArweave().createTransaction(transactionData);
     if (contentHash) {
-        logger$7('contentHash', contentHash);
-        logger$7('adding content hash tag to tx.id:', tx.id);
+        logger$6('contentHash', contentHash);
+        logger$6('adding content hash tag to tx.id:', tx.id);
         tx.addTag('Content-SHA-256', contentHash);
     }
     return tx;
@@ -7841,7 +7892,7 @@ const initItem = async () => {
         Item$2 = (await Promise.resolve().then(function () { return Item$1; })).Item;
     }
     if (!isBrowser()) {
-        Item$2 = (await import('./Item-CbgjLSUx.js')).Item;
+        Item$2 = (await import('./Item-D9HFPxsK.js')).Item;
     }
 };
 
@@ -7851,17 +7902,17 @@ const initItemProperty = async () => {
         ItemProperty$2 = (await Promise.resolve().then(function () { return ItemProperty$1; })).ItemProperty;
     }
     if (!isBrowser()) {
-        ItemProperty$2 = (await import('./ItemProperty-DduurIcl.js')).ItemProperty;
+        ItemProperty$2 = (await import('./ItemProperty-BdtvKrEy.js')).ItemProperty;
     }
 };
 
 let Db;
 const initDb = async () => {
     if (isBrowser()) {
-        Db = (await import('./Db-jMth8Y2g.js')).Db;
+        Db = (await import('./Db-C4oog-0n.js')).Db;
     }
     if (!isBrowser()) {
-        Db = (await import('./Db-DK9wSNIH.js')).Db;
+        Db = (await import('./Db-VPouegkr.js')).Db;
     }
     // TODO: Add config for React Native
 };
@@ -7878,7 +7929,7 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-const logger$6 = debug('app:react:services');
+const logger$5 = debug('app:react:services');
 const finalStrings = ['idle', 'ready', 'done', 'success', 'initialized'];
 const getServiceName = (service) => {
     let name = 'actor';
@@ -7925,7 +7976,7 @@ const getServiceUniqueKey = (service) => {
         snapshot = service.getSnapshot();
     }
     catch (error) {
-        logger$6('Error:', error);
+        logger$5('Error:', error);
         return uniqueKey;
     }
     if (snapshot) {
@@ -8154,7 +8205,7 @@ const useGlobalServiceStatus = () => {
     };
 };
 
-const logger$5 = debug('app:react:item');
+const logger$4 = debug('app:react:item');
 const useItem = ({ modelName, seedLocalId, seedUid }) => {
     // const [itemSubscription, setItemSubscription] = useState<
     //   Subscription | undefined
@@ -8231,7 +8282,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             seedUid,
         });
         if (!foundItem) {
-            logger$5('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            logger$4('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
             isReadingDb.current = false;
             return;
         }
@@ -8253,7 +8304,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             const subscription = item.subscribe(async (_) => {
                 const newItem = await Item.find({ modelName, seedLocalId, seedUid });
                 if (!newItem) {
-                    logger$5('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    logger$4('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
                     return;
                 }
                 updateItem(newItem);
@@ -8412,7 +8463,7 @@ var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     ItemProperty: ItemProperty
 });
 
-const logger$4 = debug('app:react:property');
+const logger$3 = debug('app:react:property');
 const useItemProperty = (props = {
     propertyName: '',
     seedLocalId: '',
@@ -8443,7 +8494,7 @@ const useItemProperty = (props = {
             seedUid,
         });
         if (!foundProperty) {
-            logger$4(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            logger$3(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
             isReadingDb.current = false;
             return;
         }
@@ -8480,7 +8531,7 @@ const useItemProperty = (props = {
 };
 const useItemProperties = (item) => {
     const [propertyObj, setPropertyObj] = useImmer({});
-    useState(false);
+    const [isListening, setIsListening] = useState(false);
     const updatePropertyObj = useCallback((event) => {
         if (!item) {
             console.error('[XXXXXX] [updatePropertyObj] no item when expected');
@@ -8617,10 +8668,10 @@ const withSeed = (config, webpack, isServer) => {
 
 const initEasClient = async () => {
     if (isBrowser()) {
-        (await import('./EasClient-jqkT2ZBt.js')).EasClient;
+        (await import('./EasClient-B9a3NsTi.js')).EasClient;
     }
     if (!isBrowser()) {
-        (await import('./EasClient-D3wKgt0o.js')).EasClient;
+        (await import('./EasClient-DQ93i2ci.js')).EasClient;
     }
 };
 
@@ -8629,23 +8680,23 @@ const initFileManager = async () => {
         (await Promise.resolve().then(function () { return FileManager$1; })).FileManager;
     }
     if (!isBrowser()) {
-        (await import('./FileManager-4mWYO3Mt.js')).FileManager;
+        (await import('./FileManager-_ErxVuwb.js')).FileManager;
     }
 };
 
 const initQueryClient = async () => {
     if (isBrowser()) {
-        (await import('./QueryClient-CBOP3OoU.js')).QueryClient;
+        (await import('./QueryClient-hzOtFe99.js')).QueryClient;
     }
     if (!isBrowser()) {
-        (await import('./QueryClient-bKb3SB0W.js')).QueryClient;
+        (await import('./QueryClient-Bmnv_moN.js')).QueryClient;
     }
 };
 
-const logger$3 = debug('app:services:events');
+const logger$2 = debug('app:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$3(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$2(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state));
 };
 const setupServicesEventHandlers = () => {
@@ -8671,9 +8722,9 @@ const setupServiceHandlers = () => {
     eventEmitter.addListener('service.save', saveServiceHandler);
 };
 
-const logger$2 = debug('app:ClientManager:initialize');
+const logger$1 = debug('app:ClientManager:initialize');
 const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$2('initialize from ClientManager');
+    logger$1('initialize from ClientManager');
     const { isInitialized } = context;
     const { options, } = event;
     if (isInitialized) {
@@ -8689,7 +8740,8 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
         await initQueryClient();
         await initFileManager();
         await initDb();
-        const { endpoints, models, arweaveDomain, filesDir, } = config;
+        const { models, endpoints, arweaveDomain, } = config;
+        const { files } = endpoints;
         if (arweaveDomain) {
             setArweaveDomain(arweaveDomain);
         }
@@ -8706,18 +8758,24 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
         if (!areFsListenersReady()) {
             console.error('fs listeners not ready during init');
         }
+        const globalService = getGlobalService();
         globalService.send({
             type: 'init',
             endpoints,
             models,
             addresses,
             arweaveDomain,
-            filesDir,
+            filesDir: files,
         });
-        const { models: internalModels } = await import('./seed.schema.config-B-4U2RRq.js');
+        const { models: internalModels } = await import('./seed.schema.config-BxJYabim.js');
         for (const [key, value] of Object.entries(internalModels)) {
             setModel(key, value);
         }
+        await waitFor(globalService, (snapshot) => {
+            logger$1('snapshot.value', snapshot.value);
+            return snapshot.value === GlobalState.INITIALIZED;
+        });
+        logger$1('globalService initialized');
     };
     _initialize().then(() => {
         sendBack({ type: 'initialized' });
@@ -8725,8 +8783,7 @@ const initialize = fromCallback(({ sendBack, input: { context, event } }) => {
 });
 
 debug('app:client:writeToDb');
-const saveAppState = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { key, value } = event;
+const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         const { BaseDb } = await Promise.resolve().then(function () { return BaseDb$1; });
         if (!BaseDb) {
@@ -8736,6 +8793,7 @@ const saveAppState = fromCallback(({ sendBack, input: { context, event } }) => {
         if (!appDb) {
             throw new Error('App DB not found');
         }
+        console.log(`key: ${key} value: ${value}`);
         appDb.insert(appState)
             .values({
             key: key,
@@ -8751,6 +8809,8 @@ const saveAppState = fromCallback(({ sendBack, input: { context, event } }) => {
     _saveAppState().then(() => {
         sendBack({
             type: 'saveAppStateSuccess',
+            key,
+            value,
         });
     });
 });
@@ -8765,6 +8825,7 @@ const setAddresses = assign(({ event, spawn }) => {
     });
     return {
         addresses,
+        isSaving: true,
     };
 });
 
@@ -8803,101 +8864,77 @@ const clientManagerMachine = setup({
             },
         },
         idle: {
+            entry: assign({
+                isInitialized: true,
+            }),
             on: {
-                setAddressesSuccess: {
-                    actions: assign({
-                        isSaving: false,
+                saveAppStateSuccess: {
+                    actions: assign(({ event }) => {
+                        const { key, value } = event;
+                        return {
+                            isSaving: false
+                        };
                     }),
                 },
-            },
-            setAddresses: {
-                actions: ['setAddresses'],
+                setAddresses: {
+                    actions: ['setAddresses'],
+                },
             },
         },
     },
 });
 
-const logger$1 = debug('app:client');
+const logger = debug('app:client');
 const clientManager = createActor(clientManagerMachine, {
     input: {
         isInitialized: false,
     }
 });
 const subscription = clientManager.subscribe((snapshot) => {
-    console.log('ClientManager snapshot:', 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 ClientManager = {
-    getService: () => clientManager,
+    isInitialized: () => clientManager.getSnapshot().context.isInitialized,
+    getService: () => {
+        ensureInitialized();
+        return clientManager;
+    },
     init: async (options) => {
-        clientManager.send({ type: 'init', options, });
-        await waitFor(clientManager, (snapshot) => snapshot.value === 'initialized');
+        clientManager.send({ type: 'init', options });
+        await waitFor(clientManager, (snapshot) => snapshot.context.isInitialized);
     },
     setAddresses: async (addresses) => {
-        logger$1('setAddresses', addresses);
+        ensureInitialized();
+        logger('setAddresses', addresses);
         clientManager.send({ type: 'setAddresses', addresses });
         await waitFor(clientManager, (snapshot) => !snapshot.context.isSaving);
-        logger$1('setAddresses success', addresses);
+        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);
+    },
+    stop: () => {
+        ensureInitialized();
+        clientManager.stop();
     },
-    stop: () => clientManager.stop(),
     unload: () => {
+        ensureInitialized();
         clientManager.stop();
         subscription.unsubscribe();
     },
 };
 
-const logger = debug('app:client');
-const client = {
-    isInitialized: false,
-    init: async (options) => {
-        logger('init client');
-        await ClientManager.init(options);
-        logger('client initialized');
-    },
-    setAddresses: async (addresses) => {
-        ClientManager.setAddresses(addresses);
-    },
-    subscribe: (callback) => {
-        const subscription = globalService.subscribe(callback);
-        eventEmitter.addListener('internal.globalService', callback);
-        return {
-            unsubscribe: () => {
-                subscription.unsubscribe();
-                eventEmitter.removeListener('internal.globalService', callback);
-            },
-        };
-    },
-    on: (outerEvent, callback) => {
-        eventEmitter.addListener(outerEvent, callback);
-        return {
-            unsubscribe: () => {
-                eventEmitter.removeListener(outerEvent, callback);
-            },
-        };
-    },
-    getSeedClass: async () => {
-        return new Promise((resolve) => {
-            const subscription = globalService.subscribe((snapshot) => {
-                if (snapshot.status === 'done') {
-                    resolve(snapshot.output);
-                }
-            });
-            globalService.send({ type: 'getSeed' });
-            subscription.unsubscribe();
-        });
-    },
-    getModel: (modelName) => {
-        return getModel(modelName);
-    },
-    getModels: () => {
-        return getModels();
-    },
-    getModelNames: () => {
-        return getModelNames();
-    },
-};
-
 enableMapSet();
 
-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-CTZqN6WI.js.map
+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-BSR5hv7Q.js.map