@seedprotocol/sdk 0.1.18 → 0.1.19

package/dist/{events-So24__c6.js → index-D3JMvAuO.js}

@@ -1,30 +1,31 @@
+import { _ as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_DATA_TYPES } from './constants-KW2RTtZB.js';
+import path, { basename } from 'path';
+import 'reflect-metadata';
+import { Type } from '@sinclair/typebox';
 import { fromCallback, setup, assign, createActor, waitFor, emit } from 'xstate';
-import { createBrowserInspector } from '@statelyai/inspect';
+import { sql, relations, and, eq, max, or, count, isNull } from 'drizzle-orm';
 import { fs, configureSingle } from '@zenfs/core';
-import { sql, count, max, eq, and, or, isNull, relations } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/sqlite-proxy';
+import 'dayjs';
+import { customAlphabet } from 'nanoid';
+import * as nanoIdDictionary from 'nanoid-dictionary';
 import debug from 'debug';
+import { startCase, debounce, camelCase, orderBy } from 'lodash-es';
+import { sqliteTable, text, int, blob, check, unique } from 'drizzle-orm/sqlite-core';
+import EventEmitter from 'eventemitter3';
 import { QueryClient } from '@tanstack/react-query';
 import { GraphQLClient } from 'graphql-request';
 import { createSyncStoragePersister } from '@tanstack/query-sync-storage-persister';
 import { persistQueryClient } from '@tanstack/react-query-persist-client';
-import path, { basename } from 'path';
-import { sqliteTable, text, int, blob, check, unique } from 'drizzle-orm/sqlite-core';
-import 'dayjs';
-import { customAlphabet } from 'nanoid';
-import * as nanoIdDictionary from 'nanoid-dictionary';
-import { WebAccess } from '@zenfs/dom';
-import Arweave from 'arweave';
-import { startCase, debounce, camelCase, orderBy } from 'lodash-es';
+import { BehaviorSubject } from 'rxjs';
+import { immerable, produce, enableMapSet } from 'immer';
 import pluralize from 'pluralize';
+import Arweave from 'arweave';
 import { useState, useCallback, useEffect, useRef } from 'react';
-import { BehaviorSubject } from 'rxjs';
-import { immerable, produce } from 'immer';
 import { useImmer } from 'use-immer';
 import { useSelector } from '@xstate/react';
-import 'reflect-metadata';
-import { Type } from '@sinclair/typebox';
-import EventEmitter from 'eventemitter3';
+import { createBrowserInspector } from '@statelyai/inspect';
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
+import { WebAccess } from '@zenfs/dom';
 
 const isNode = () => {
     return (typeof process !== 'undefined' &&
@@ -38,686 +39,208 @@ const isReactNative = () => {
     return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __metadata(metadataKey, metadataValue) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+const withSeed$1 = (config, webpack, isServer) => {
+    // If you need to include directories outside of the project root
+    // config.module.rules.push({
+    //   test: /\.ts$/,
+    //   include: [path.resolve(process.cwd(), 'schema.ts')],
+    //   use: 'ts-loader',
+    // })
+    config.plugins.push(
+    // new webpack.DefinePlugin({
+    //   __dirname: JSON.stringify(__dirname),
+    // }),
+    new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
+        resource.request = resource.request.replace(/^node:/, '');
+    }));
+    // config.externals.push({
+    //   'fsevents': 'commonjs2 fsevents',
+    // })
+    // console.log('__dirname:', __dirname)
+    // console.log('process.cwd():', process.cwd())
+    // console.log('crypto-browserify exists:', fs.existsSync(path.resolve(process.cwd(), './node_modules/crypto-browserify')))
+    // console.log('path-browserify exists:', fs.existsSync(path.resolve(process.cwd(), './node_modules/path-browserify')))
+    if (!isServer) {
+        console.log('config.resolve.alias:', config.resolve.alias);
+        config.resolve.alias['fs'] = path.resolve(process.cwd(), './node_modules/@zenfs/core');
+        config.resolve.alias['node:fs'] = path.resolve(process.cwd(), './node_modules/@zenfs/core');
+        config.resolve.alias['@schema'] = path.resolve(process.cwd(), 'schema.ts');
+        // config.resolve.alias['crypto']      = path.resolve(process.cwd(), './node_modules/crypto-browserify')
+        // config.resolve.alias['node:crypto'] = path.resolve(process.cwd(), './node_modules/crypto-browserify')
+        config.resolve.alias['node:path'] = path.resolve(process.cwd(), './node_modules/path-browserify');
+        config.resolve.alias['path'] = path.resolve(process.cwd(), './node_modules/path-browserify');
+    }
+    if (isServer) {
+        config.externals.push('@sqlite.org/sqlite-wasm');
+        config.externals.push('nunjucks');
+        config.externals.push('chokidar');
+        config.externals.push('arweave');
+    }
+    // config.module.rules.push({
+    //   test: /seed\.config\.mjs$/,
+    //     use: [
+    //       {
+    //         loader: 'babel-loader',
+    //         options: {
+    //           plugins: ['@babel/plugin-syntax-dynamic-import'],
+    //         },
+    //       },
+    //     ],
+    // })
+    return config;
 };
 
-var MachineIds;
-(function (MachineIds) {
-    MachineIds["GLOBAL"] = "@seedSdk/global";
-    MachineIds["INTERNAL"] = "@seedSdk/internal";
-    MachineIds["DB"] = "@seedSdk/db";
-    MachineIds["EAS"] = "@seedSdk/eas";
-    MachineIds["ITEM"] = "@seedSdk/item";
-    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
-    MachineIds["MODEL"] = "@seedSdk/model";
-    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
-})(MachineIds || (MachineIds = {}));
-const { INTERNAL, DB, GLOBAL, EAS, MODEL } = MachineIds;
-var GlobalState;
-(function (GlobalState) {
-    GlobalState["UNINITIALIZED"] = "uninitialized";
-    GlobalState["INITIALIZING"] = "initializing";
-    GlobalState["INITIALIZED"] = "initialized";
-    GlobalState["GETTING_SEED_CLASS"] = "gettingSeedClass";
-    GlobalState["GETTING_SCHEMA_FOR_MODEL"] = "gettingSchemaForModel";
-    GlobalState["GETTING_TABLE_FOR_MODEL"] = "gettingTableForModel";
-    GlobalState["GETTING_MODEL_CLASS"] = "gettingModelClass";
-    GlobalState["ADDING_MODELS_TO_DB"] = "addingModelsToDb";
-})(GlobalState || (GlobalState = {}));
-const { UNINITIALIZED: UNINITIALIZED$1, INITIALIZING: INITIALIZING$1, INITIALIZED: INITIALIZED$1, GETTING_SEED_CLASS: GETTING_SEED_CLASS$1, GETTING_SCHEMA_FOR_MODEL: GETTING_SCHEMA_FOR_MODEL$1, GETTING_TABLE_FOR_MODEL, GETTING_MODEL_CLASS, ADDING_MODELS_TO_DB: ADDING_MODELS_TO_DB$1, } = GlobalState;
-var InternalState;
-(function (InternalState) {
-    InternalState["IDLE"] = "idle";
-    InternalState["INITIALIZING"] = "initializing";
-    InternalState["VALIDATING_INPUT"] = "validatingInput";
-    InternalState["CONFIGURING_FS"] = "configuringFs";
-    InternalState["LOADING_SEED_DB"] = "loadingSeedDb";
-    InternalState["SAVING_CONFIG"] = "savingConfig";
-    InternalState["LOADING_DBS"] = "loadingDbs";
-    InternalState["LOADING_APP_DB"] = "loadingAppDb";
-    InternalState["LOADING_SDK_DB"] = "loadingSdkDb";
-})(InternalState || (InternalState = {}));
-const { VALIDATING_INPUT: VALIDATING_INPUT$1, CONFIGURING_FS: CONFIGURING_FS$1, LOADING_SEED_DB: LOADING_SEED_DB$1, LOADING_APP_DB: LOADING_APP_DB$1, LOADING_SDK_DB: LOADING_SDK_DB$1, } = InternalState;
-var DbState;
-(function (DbState) {
-    DbState["CHECKING_STATUS"] = "checkingStatus";
-    DbState["WAITING_FOR_FILES"] = "waitingForFiles";
-    DbState["VALIDATING"] = "validating";
-    DbState["CONNECTING_TO_DB"] = "connectingToDb";
-    // FETCHING_MIGRATIONS = 'fetchingMigrations',
-    DbState["MIGRATING"] = "migrating";
-})(DbState || (DbState = {}));
-const { CHECKING_STATUS: CHECKING_STATUS$1, VALIDATING: VALIDATING$1, CONNECTING_TO_DB: CONNECTING_TO_DB$1, WAITING_FOR_FILES: WAITING_FOR_FILES$1, MIGRATING: MIGRATING$1, } = DbState;
-const INTERNAL_VALIDATING_INPUT_SUCCESS = `${INTERNAL}.${VALIDATING_INPUT$1}.success`;
-const INTERNAL_CONFIGURING_FS_SUCCESS = `${INTERNAL}.${CONFIGURING_FS$1}.success`;
-const INTERNAL_LOADING_SEED_DB_SUCCESS = `${INTERNAL}.${LOADING_SEED_DB$1}.success`;
-const INTERNAL_LOADING_APP_DB_SUCCESS = `${INTERNAL}.${LOADING_APP_DB$1}.success`;
-const INTERNAL_LOADING_SDK_DB_SUCCESS = `${INTERNAL}.${LOADING_SDK_DB$1}.success`;
-const INTERNAL_SAVING_CONFIG_SUCCESS = `${INTERNAL}.savingConfig.success`;
-const GLOBAL_INITIALIZING_SEND_CONFIG = `${GLOBAL}.${INITIALIZING$1}.sendConfig`;
-const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY = `${GLOBAL}.${INITIALIZING$1}.internalServiceReady`;
-const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS = `${GLOBAL}.${ADDING_MODELS_TO_DB$1}.success`;
-const DB_CHECK_STATUS_UPDATE_PATHS = `${DB}.${CHECKING_STATUS$1}.updatePaths`;
-const DB_CHECK_STATUS_EXISTS = `${DB}.${CHECKING_STATUS$1}.exists`;
-const DB_VALIDATING_SUCCESS = `${DB}.${VALIDATING$1}.success`;
-const DB_VALIDATING_WAIT = `${DB}.${VALIDATING$1}.wait`;
-const DB_MIGRATING_WAIT = `${DB}.${MIGRATING$1}.wait`;
-const DB_MIGRATING_SUCCESS = `${DB}.${MIGRATING$1}.success`;
-const DB_CREATING_SUCCESS = `${DB}.${CONNECTING_TO_DB$1}.success`;
-const DB_WAITING_FOR_FILES_RECEIVED = `${DB}.${WAITING_FOR_FILES$1}.filesReceived`;
-const DB_ON_SNAPSHOT = `${DB}.onSnapshot`;
-const CHILD_SNAPSHOT = 'childSnapshot';
-const DB_NAME_SEED = 'seed_db';
-const DB_NAME_APP = 'app_db';
-const DB_NAME_SDK_CONFIG = 'sdk_config_db';
-const DB_DIR_NAME_SEED = 'seed';
-const DB_DIR_NAME_APP = 'app';
-const DB_DIR_NAME_SDK = 'sdk';
-const BROWSER_FS_TOP_DIR = 'app-files';
-const EAS_ENDPOINT = process.env.NEXT_PUBLIC_EAS_ENDPOINT ||
-    process.env.EAS_ENDPOINT ||
-    'https://optimism-sepolia.easscan.org/graphql';
-const ARWEAVE_HOST = process.env.NEXT_PUBLIC_ARWEAVE_HOST || 'permagate.io';
-
 let sqlite3InitModule;
-let sqliteWasmClient$1;
+let sqliteWasmClient;
 let isPreparing = false;
-
-const getSqlite = async () => {
-  if (sqliteWasmClient$1) {
-    return sqliteWasmClient$1
-  }
-  if (typeof window === 'undefined') {
-    throw new Error('validateInput called from non-browser context')
-  }
-
-  if (isPreparing) {
-    return
-  }
-
-  isPreparing = true;
-
-  if (!sqlite3InitModule) {
-    sqlite3InitModule = await import('@sqlite.org/sqlite-wasm');
-  }
-
-  if (!window.sqlite3Worker1Promiser) {
-    await sqlite3InitModule();
-  }
-
-  if (!window.sqlite3Worker1Promiser) {
-    console.error('window.sqlite3Worker1Promiser not found');
-    isPreparing = false;
-    return
-  }
-
-  try {
-    sqliteWasmClient$1 = await window.sqlite3Worker1Promiser.v2().catch((err) => {
-      console.error('Error initializing sqliteWasmClient:', err);
-      isPreparing = false;
-    });
-  } catch (err) {
-    console.error('Error initializing sqliteWasmClient:', err);
-    isPreparing = false;
-  }
+const getSqliteWasmClient = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (sqliteWasmClient) {
+        return sqliteWasmClient;
+    }
+    if (typeof window === 'undefined') {
+        throw new Error('validateInput called from non-browser context');
+    }
+    if (isPreparing) {
+        return;
+    }
+    isPreparing = true;
+    if (!sqlite3InitModule) {
+        sqlite3InitModule = yield import('@sqlite.org/sqlite-wasm');
+    }
+    if (!window.sqlite3Worker1Promiser) {
+        yield sqlite3InitModule();
+    }
+    if (!window.sqlite3Worker1Promiser) {
+        console.error('window.sqlite3Worker1Promiser not found');
+        isPreparing = false;
+        return;
+    }
+    try {
+        sqliteWasmClient = yield window.sqlite3Worker1Promiser.v2().catch((err) => {
+            console.error('Error initializing sqliteWasmClient:', err);
+            isPreparing = false;
+        });
+    }
+    catch (err) {
+        console.error('Error initializing sqliteWasmClient:', err);
+        isPreparing = false;
+    }
+    return sqliteWasmClient;
+});
+let appDb;
+const setAppDb = (db) => {
+    appDb = db;
+};
+const getAppDb = () => {
+    if (!appDb) {
+        throw new Error('getAppDb: appDb is undefined');
+    }
+    return appDb;
+};
+const isAppDbReady = () => {
+    return !!appDb;
 };
+const runQueryForStatement = (statement) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    return appDb.run(sql.raw(statement));
+});
 
-const logger$l = debug('app:db:actors');
-let seedDb;
-let appDb;
-let sdkConfigDb;
-let sqliteWasmClient;
-const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
-    const { dbName, dirName } = context;
-    logger$l('[db/actors] checkStatus context', context);
-    const pathToDir = `${BROWSER_FS_TOP_DIR}/${dirName}`;
-    const pathToDbDir = `${pathToDir}/db`;
-    const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
-    sendBack({
-        type: DB_CHECK_STATUS_UPDATE_PATHS,
-        pathToDb,
-        pathToDir,
-        pathToDbDir,
-    });
-    const _checkStatus = () => __awaiter(void 0, void 0, void 0, function* () {
-        // logger('[db/actors] _checkStatus pathToDb', pathToDb)
-        // const exists = await fs.promises.exists(pathToJournal)
-        // if (exists) {
-        //   sendBack({
-        //     type: DB_CHECK_STATUS_EXISTS,
-        //   })
-        //   return
-        // }
-        //
-        // return new Promise((resolve) => {
-        //   sendBack({ type: DB_CHECK_STATUS_DOES_NOT_EXIST })
-        //
-        // })
+const waitForDb$1 = fromCallback(({ sendBack }) => {
+    const _waitForDb = new Promise((resolve) => {
+        const interval = setInterval(() => {
+            const appDb = getAppDb();
+            if (appDb) {
+                clearInterval(interval);
+                resolve();
+            }
+        }, 100);
     });
-    _checkStatus().then(() => {
-        sendBack({ type: DB_CHECK_STATUS_EXISTS });
-        return;
+    _waitForDb.then(() => {
+        sendBack({ type: 'waitForDbSuccess' });
     });
 });
-const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$l('[db/actors] connectToDb context', context);
-    const { dbName, pathToDir } = context;
-    let isConnecting = false;
-    let dbId;
-    const _create = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (isConnecting) {
+
+const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
+    const { isRelation, propertyName, storageTransactionId, seedLocalId } = context;
+    if (isRelation) {
+        sendBack({ type: 'isRelatedProperty' });
+        sendBack({ type: 'initializeSuccess' });
+        return;
+    }
+    if (!isRelation) {
+        if ((propertyName !== 'html' && propertyName !== 'json') ||
+            !storageTransactionId) {
+            sendBack({ type: 'initializeSuccess' });
             return;
         }
-        isConnecting = true;
-        let response;
-        if (!sqliteWasmClient) {
-            sqliteWasmClient = yield getSqlite();
-        }
-        //@ts-ignore
-        response = yield sqliteWasmClient('config-get', {});
-        logger$l(response);
-        logger$l('Running SQLite3 version', response.result.version.libVersion);
-        //@ts-ignore
-        response = yield sqliteWasmClient('open', {
-            filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
+        const _getContentsFromFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (propertyName === 'html') {
+                const renderValue = yield fs.promises
+                    .readFile(`/files/html/${storageTransactionId}.html`, 'utf8')
+                    .catch((error) => {
+                    console.warn('Error reading html file', error);
+                });
+                sendBack({ type: 'updateRenderValue', renderValue });
+                return;
+            }
+            if (propertyName === 'json') {
+                const renderValue = yield fs.promises
+                    .readFile(`/files/json/${storageTransactionId}.json`, 'utf8')
+                    .catch((error) => {
+                    console.warn('Error reading json file', error);
+                });
+                sendBack({ type: 'updateRenderValue', renderValue });
+                return;
+            }
         });
-        logger$l(response);
-        dbId = response.dbId;
-        // logger(`dbId: ${dbId}`)
-        logger$l('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
-    });
-    const interval = setInterval(() => {
-        // TODO: Add a timeout
-        // TODO: Add a cancel token to the promise so we can prevent more loops starting while we're checking the successful outcome
-        if (dbId) {
-            // logger(
-            //   '[db/actors] opening sqliteWasm connection with dbId:',
-            //   dbId,
-            // )
-            clearInterval(interval);
-            sendBack({ type: DB_CREATING_SUCCESS, dbId });
-            return;
-        }
-        _create()
-            .then(() => {
-            return;
-        })
-            .catch((e) => {
-            isConnecting = false;
+        _getContentsFromFileSystem().then(() => {
+            sendBack({ type: 'initializeSuccess' });
         });
-    }, 500);
-    return () => {
-        if (interval) {
-            clearInterval(interval);
-        }
-    };
+    }
 });
-const validate = fromCallback(({ sendBack, input: { context } }) => {
-    const { pathToDir, pathToDb } = context;
-    const pathsToCheck = [
-        pathToDir,
-        `${pathToDir}/db`,
-        `${pathToDir}/db/meta`,
-        `${pathToDir}/db/meta/_journal.json`,
-    ];
-    const _validate = () => __awaiter(void 0, void 0, void 0, function* () {
-        // If any of the necessary files don't exist, we wipe them all and recreate
-        let exists = false;
-        for (const path of pathsToCheck) {
-            exists = yield fs.promises.exists(path);
-            if (!exists) {
-                sendBack({
-                    type: DB_VALIDATING_WAIT,
-                });
-                return false;
-            }
-        }
-        return exists;
-    });
-    _validate().then(() => {
-        sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir });
+
+const logger$n = debug('app:shared:helpers');
+const { alphanumeric } = nanoIdDictionary;
+const generateId = () => {
+    return customAlphabet(alphanumeric, 10)();
+};
+const toSnakeCase = (str) => {
+    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+};
+const identifyString = (str) => {
+    try {
+        JSON.parse(str);
+        return 'json';
+    }
+    catch (e) {
+        // Not JSON
+    }
+    if (!str) {
         return;
-    });
-});
-const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void 0, [dbId_1, params_1, sql_1, dbName_1, ...args_1], void 0, function* (dbId, params, sql, dbName, retries = 2) {
-    const rowsToReturnRaw = [];
-    const sqliteWasmClient = yield getSqlite();
-    // For a single exec command, the callback potentially gets called several times -- once for each row.
-    // So we need to collect all rows into a final array to return (execResult).
-    const rowsToReturn = yield new Promise((resolve, reject) => {
-        sqliteWasmClient('exec', {
-            dbId,
-            sql,
-            bind: params,
-            callback: (result) => {
-                // Checks if this is the final callback of the query
-                if (!result || !result.row || !result.rowNumber) {
-                    const returnResult = [];
-                    // Before returning the array, we process it to match the expected output format
-                    // const rowsToReturnProcessed = rowsToReturnRaw.reduce((acc, curr) => {
-                    //   if (
-                    //     Array.isArray(curr.row) &&
-                    //     curr.row?.length > 0 &&
-                    //     curr.columnNames.length > 0
-                    //   ) {
-                    //     const returnObj: ReturnObj = {
-                    //       database: dbName,
-                    //     }
-                    //
-                    //     const values = []
-                    //
-                    //     curr.columnNames.forEach((colName, index: number) => {
-                    //       if (curr.row && curr.row[index]) {
-                    //         returnObj[colName] = curr.row[index]
-                    //         values.push(curr.row[index])
-                    //       }
-                    //     })
-                    //     // rowsValueStrings.push(`(${values.join(', ')})`)
-                    //     acc.push(returnObj)
-                    //   }
-                    //   return acc
-                    // }, [] as string[])
-                    for (const currRow of rowsToReturnRaw) {
-                        // const values: string[] = []
-                        // currRow.columnNames.forEach((colName, index: number) => {
-                        //   if (currRow.row) {
-                        //     values.push(currRow.row[index])
-                        //   }
-                        // })
-                        // logger(`[db/actors] [dbExec] currRow`, currRow)
-                        returnResult.push(currRow.row);
-                    }
-                    resolve(returnResult);
-                }
-                else {
-                    // If not the final response, add this row to the return array
-                    rowsToReturnRaw.push(result);
-                }
-            },
-        }).catch((error) => __awaiter(void 0, void 0, void 0, function* () {
-            reject(error);
-        }));
-    });
-    // logger(`[db/actors] [dbExec] rowsToReturn`, rowsToReturn)
-    // logger(`[db/actors] [dbExec] rowsValues`, rowsValues)
-    return rowsToReturn || [];
-});
-const migrate = fromCallback(({ sendBack, input: { context } }) => {
-    const { pathToDbDir, dirName, dbId, dbName } = context;
-    logger$l('[db/actors] migrate context', context);
-    const schemaGlobString = `${BROWSER_FS_TOP_DIR}/${dirName}/schema/*`;
-    const isSeedDb = dbName === DB_NAME_SEED;
-    const isAppDb = dbName === DB_NAME_APP;
-    const isSdkConfigDb = dbName === DB_NAME_SDK_CONFIG;
-    if (!sqliteWasmClient) {
-        throw new Error('Sqlite wasm client not initialized');
     }
-    let journalExists = false;
-    // const _initFs = async (): Promise<void> => {
-    //   const handle = await navigator.storage.getDirectory()
-    //   // await configure({ backend: WebAccess, handle })
-    //   await configureSingle({
-    //     backend: WebAccess,
-    //     handle,
-    //   })
-    // }
-    //
-    // _initFs()
-    const _checkForFiles = () => __awaiter(void 0, void 0, void 0, function* () {
-        const { fs } = yield import('@zenfs/core');
-        journalExists = yield fs.promises.exists(`/${pathToDbDir}/meta/_journal.json`);
-        if (!journalExists) {
-            window.location.reload();
-            // setTimeout(() => {
-            //   _checkForFiles().then(() => {
-            //     return
-            //   })
-            // }, 500)
-        }
-    });
-    const _migrate = () => __awaiter(void 0, void 0, void 0, function* () {
-        const drizzleDb = drizzle((sql, params, method) => __awaiter(void 0, void 0, void 0, function* () {
-            try {
-                // logger(
-                //   `executing sql on ${dbName} with id: ${dbId} and method: ${method}`,
-                //   sql,
-                // )
-                const finalResult = yield dbExec(dbId, params, sql, dbName);
-                // logger(`finalResult with method: ${method}`, finalResult)
-                // Drizzle always waits for {rows: string[][]} or {rows: string[]} for the return value.
-                // When the method is get,  you should return a value as {rows: string[]}.
-                // Otherwise, you should return {rows: string[][]}.
-                return { rows: finalResult };
-            }
-            catch (e) {
-                console.error('Error from sqlite proxy server: ', JSON.stringify(e));
-                return { rows: [] };
-            }
-        }), {
-            schema: schemaGlobString,
-            // logger: true,
-        });
-        const { migrate: drizzleMigrate } = yield import('drizzle-orm/sqlite-proxy/migrator');
-        const { readMigrationFiles } = yield import('drizzle-orm/migrator');
-        try {
-            const migrations = readMigrationFiles({
-                migrationsFolder: pathToDbDir,
-            });
-            if (migrations.length > 0) {
-                const incomingMigrationHashes = migrations.map((migration) => migration.hash);
-                let existingMigrationHashes;
-                let rows = [];
-                try {
-                    const query = yield drizzleDb.run(sql.raw(`SELECT hash, created_at
-                 FROM main.__drizzle_migrations;`));
-                    rows = query.rows;
-                }
-                catch (e) {
-                    rows = [];
-                }
-                if (rows && rows.length > 0) {
-                    existingMigrationHashes = rows.map((row) => row[0]);
-                }
-                if (existingMigrationHashes) {
-                    let shouldRebuildDb = false;
-                    for (const existingHash of existingMigrationHashes) {
-                        if (!incomingMigrationHashes.includes(existingHash)) {
-                            shouldRebuildDb = true;
-                            break;
-                        }
-                    }
-                    if (shouldRebuildDb) {
-                        yield fs.promises.unlink(`${pathToDbDir}/${dbName}.sqlite3`);
-                    }
-                }
-            }
-            yield drizzleMigrate(drizzleDb, (queriesToRun) => __awaiter(void 0, void 0, void 0, function* () {
-                // logger('queriesToRun', queriesToRun)
-                for (const query of queriesToRun) {
-                    // logger('query', query)
-                    yield drizzleDb.run(sql.raw(query));
-                }
-            }), {
-                migrationsFolder: pathToDbDir,
-            });
-        }
-        catch (error) {
-            console.error('Error migrating database: ', error);
-            window.location.reload();
-        }
-        // TODO: We're currently only using seedDb for appState ... should we drop it?
-        // Or do we want to store Seeds and Versions separately from appDb and sdkConfigDb?
-        if (isSeedDb) {
-            seedDb = drizzleDb;
-        }
-        if (isAppDb) {
-            appDb = drizzleDb;
-            // const createTempTableQuery = await appDb.run(
-            //   sql.raw(
-            //     `CREATE TEMP TABLE IF NOT EXISTS temp_last_inserted_id (id INTEGER, table TEXT);`,
-            //   ),
-            // )
-            //
-            // logger(
-            //   '[db/actors] [migrate] createTempTableQuery',
-            //   createTempTableQuery,
-            // )
-            // const triggersQuery = await appDb.run(
-            //   sql.raw(
-            //     `SELECT name
-            //      FROM main.sqlite_master
-            //      WHERE type = 'trigger';`,
-            //   ),
-            // )
-            //
-            // logger('[db/actors] [migrate] triggersQuery', triggersQuery)
-            //
-            // const triggers = triggersQuery.rows.map((row) => row[0])
-            //
-            // const tablesQuery = await appDb.run(
-            //   sql.raw(
-            //     `SELECT name
-            //      FROM main.sqlite_master
-            //      WHERE type = 'table';`,
-            //   ),
-            // )
-            //
-            // logger('[db/actors] [migrate] tablesQuery', tablesQuery)
-            //
-            // const tableNames = tablesQuery.rows.map((row) => row[0])
-            // logger('[db/actors] [migrate] tableNames', tableNames)
-            // for (const tableName of tableNames) {
-            //   const triggerName = `after_insert_${tableName}`
-            //   if (triggers.includes(triggerName)) {
-            //     continue
-            //   }
-            //           const createTriggerQuery = await appDb.run(
-            //             sql.raw(
-            //               `CREATE TRIGGER after_insert_${tableName}
-            // AFTER INSERT ON ${tableName}
-            // BEGIN
-            //     DELETE FROM temp_last_inserted_id;
-            //     INSERT INTO temp_last_inserted_id (id) VALUES (new.id);
-            // END;`,
-            //             ),
-            //           )
-            //
-            //           logger(
-            //             '[db/actors] [migrate] createTriggerQuery',
-            //             createTriggerQuery,
-            //           )
-            //         }
-        }
-        if (isSdkConfigDb) {
-            sdkConfigDb = drizzleDb;
-        }
-    });
-    _checkForFiles()
-        .then(() => {
-        if (((isSeedDb && !seedDb) ||
-            (isAppDb && !appDb) ||
-            (isSdkConfigDb && !sdkConfigDb)) &&
-            journalExists) {
-            return _migrate();
-        }
-    })
-        .then(() => {
-        sendBack({ type: DB_MIGRATING_SUCCESS, dbName });
-    });
-    return () => { };
-});
-const getDb = (dbName) => {
-    if (dbName === DB_NAME_SEED && seedDb) {
-        return seedDb;
+    if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+        return 'html';
     }
-    if (dbName === DB_NAME_APP && appDb) {
-        return appDb;
+    // Simple markdown checks (very naive)
+    if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+        return 'markdown';
     }
-    if (dbName === DB_NAME_SDK_CONFIG && sdkConfigDb) {
-        return sdkConfigDb;
+    if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+        return 'base64';
     }
-    return null;
+    // Default to plain text if unsure
+    return 'text';
 };
-const getAppDb = () => {
-    const appDb = getDb(DB_NAME_APP);
-    if (!appDb) {
-        throw new Error('getAppDb: appDb is undefined');
+const getMimeType = (base64) => {
+    if (!base64 || !Object.hasOwn(base64, 'match')) {
+        return null;
     }
-    return appDb;
-};
-const getSdkDb = () => {
-    const sdkDb = getDb(DB_NAME_SDK_CONFIG);
-    if (!sdkDb) {
-        throw new Error('getSdkDb: sdkDb is undefined');
-    }
-    return sdkDb;
-};
-// export const getDb = fromCallback<EventObject, typeof dbMachine>(
-//   ({ sendBack, receive, input: { event } }) => {
-//     const { dbName } = event
-//
-//     const _getDb = async (): Promise<void> => {
-//       const db = await drizzle(dbName)
-//       sendBack({ type: 'returningDb', db })
-//     }
-//
-//     _getDb().then(() => {
-//       return
-//     })
-//
-//     return () => {}
-//   },
-// )
-
-const waitForDb$1 = fromCallback(({ sendBack }) => {
-    const _waitForDb = new Promise((resolve) => {
-        const interval = setInterval(() => {
-            const appDb = getDb(DB_NAME_APP);
-            const sdkConfigDb = getSdkDb();
-            if (appDb || !sdkConfigDb) {
-                clearInterval(interval);
-                resolve();
-            }
-        }, 100);
-    });
-    _waitForDb.then(() => {
-        sendBack({ type: 'waitForDbSuccess' });
-    });
-});
-
-const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
-    const { isRelation, propertyName, storageTransactionId, seedLocalId } = context;
-    if (isRelation) {
-        sendBack({ type: 'isRelatedProperty' });
-        sendBack({ type: 'initializeSuccess' });
-        return;
-    }
-    if (!isRelation) {
-        if ((propertyName !== 'html' && propertyName !== 'json') ||
-            !storageTransactionId) {
-            sendBack({ type: 'initializeSuccess' });
-            return;
-        }
-        const _getContentsFromFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
-            if (propertyName === 'html') {
-                const renderValue = yield fs.promises
-                    .readFile(`/files/html/${storageTransactionId}.html`, 'utf8')
-                    .catch((error) => {
-                    console.warn('Error reading html file', error);
-                });
-                sendBack({ type: 'updateRenderValue', renderValue });
-                return;
-            }
-            if (propertyName === 'json') {
-                const renderValue = yield fs.promises
-                    .readFile(`/files/json/${storageTransactionId}.json`, 'utf8')
-                    .catch((error) => {
-                    console.warn('Error reading json file', error);
-                });
-                sendBack({ type: 'updateRenderValue', renderValue });
-                return;
-            }
-        });
-        _getContentsFromFileSystem().then(() => {
-            sendBack({ type: 'initializeSuccess' });
-        });
-    }
-});
-
-const logger$k = debug('app:shared:helpers');
-const { alphanumeric } = nanoIdDictionary;
-const generateId = () => {
-    return customAlphabet(alphanumeric, 10)();
-};
-const toSnakeCase = (str) => {
-    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-};
-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 || !Object.hasOwn(base64, 'match')) {
-        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 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 getImageDataType = (data) => {
@@ -739,7 +262,7 @@ const convertTxIdToImageSrc = (txId) => __awaiter(void 0, void 0, void 0, functi
     const imageFilePath = `/files/images/${txId}`;
     const fileExists = yield fs.promises.exists(imageFilePath);
     if (!fileExists) {
-        logger$k(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$n(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
     const uint = yield fs.promises.readFile(imageFilePath);
@@ -817,30 +340,70 @@ const appState = sqliteTable('appState', {
     updatedAt: int('updated_at'),
 });
 
-const getItemsData = (modelName) => __awaiter(void 0, void 0, void 0, function* () {
-    const appDb = getAppDb();
-    const itemsData = (yield appDb
-        .select({
-        seedLocalId: seeds.localId,
-        seedUid: seeds.uid,
-        schemaUid: seeds.schemaUid,
-        modelName: sql `${modelName}`,
-        attestationCreatedAt: seeds.attestationCreatedAt,
-        versionsCount: count(versions.localId),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt),
-        lastLocalUpdateAt: max(versions.createdAt),
-    })
-        .from(seeds)
-        .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
-        .where(and(eq(seeds.type, modelName.toLowerCase()), or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0))))
-        .groupBy(seeds.localId));
-    return itemsData;
+sqliteTable('config', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    key: text('key').notNull(),
+    text: text('text'),
+    json: text('json', { mode: 'json' }),
+    blob: blob('blob', { mode: 'buffer' }),
+}, () => {
+    return {
+        // Add a custom check constraint
+        atLeastOneNotNull: check('hasValue', sql `key IS NOT NULL OR text IS NOT NULL OR json IS NOT NULL OR blob IS NOT NULL`),
+    };
 });
 
-const runQueryForStatement = (statement) => __awaiter(void 0, void 0, void 0, function* () {
-    const appDb = getAppDb();
-    return appDb.run(sql.raw(statement));
+const models = sqliteTable('models', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+});
+relations(models, ({ many }) => ({
+    properties: many(properties),
+}));
+const properties = sqliteTable('properties', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    dataType: text('data_type').notNull(),
+    readEndpoint: text('read_endpoint'),
+    updateEndpoint: text('update_endpoint'),
+    modelId: int('model_id')
+        .notNull()
+        .references(() => models.id),
+    refModelId: int('ref_model_id').references(() => models.id),
+    refValueType: text('ref_value_type'),
+}, (table) => {
+    return {
+        uniqueNameModelId: unique('unique_name_model_id').on(table.name, table.modelId),
+    };
+});
+relations(properties, ({ one }) => ({
+    model: one(models),
+    refModel: one(models),
+}));
+
+const modelUids = sqliteTable('model_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    modelId: int('model_id')
+        .notNull()
+        .unique()
+        .references(() => models.id),
+});
+relations(modelUids, ({ many, one }) => ({
+    model: one(models),
+}));
+
+const propertyUids = sqliteTable('property_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    propertyId: int('property_id')
+        .notNull()
+        .unique()
+        .references(() => models.id),
 });
+relations(propertyUids, ({ one }) => ({
+    property: one(properties),
+}));
 
 const getPropertyData = (propertyName, seedLocalId) => __awaiter(void 0, void 0, void 0, function* () {
     const query = `SELECT local_id,
@@ -1314,71 +877,6 @@ const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-sqliteTable('config', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    key: text('key').notNull(),
-    text: text('text'),
-    json: text('json', { mode: 'json' }),
-    blob: blob('blob', { mode: 'buffer' }),
-}, () => {
-    return {
-        // Add a custom check constraint
-        atLeastOneNotNull: check('hasValue', sql `key IS NOT NULL OR text IS NOT NULL OR json IS NOT NULL OR blob IS NOT NULL`),
-    };
-});
-
-const models = sqliteTable('models', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-});
-relations(models, ({ many }) => ({
-    properties: many(properties),
-}));
-const properties = sqliteTable('properties', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-    dataType: text('data_type').notNull(),
-    readEndpoint: text('read_endpoint'),
-    updateEndpoint: text('update_endpoint'),
-    modelId: int('model_id')
-        .notNull()
-        .references(() => models.id),
-    refModelId: int('ref_model_id').references(() => models.id),
-    refValueType: text('ref_value_type'),
-}, (table) => {
-    return {
-        uniqueNameModelId: unique('unique_name_model_id').on(table.name, table.modelId),
-    };
-});
-relations(properties, ({ one }) => ({
-    model: one(models),
-    refModel: one(models),
-}));
-
-const modelUids = sqliteTable('model_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    modelId: int('model_id')
-        .notNull()
-        .unique()
-        .references(() => models.id),
-});
-relations(modelUids, ({ many, one }) => ({
-    model: one(models),
-}));
-
-const propertyUids = sqliteTable('property_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    propertyId: int('property_id')
-        .notNull()
-        .unique()
-        .references(() => models.id),
-});
-relations(propertyUids, ({ one }) => ({
-    property: one(properties),
-}));
-
 const writeAppState = (db, key, value) => __awaiter(void 0, void 0, void 0, function* () {
     yield db
         .insert(appState)
@@ -1400,109 +898,17 @@ const escapeSqliteString = (value) => {
     }
     return value.replace(/'/g, "''");
 };
-const createOrUpdate = (db, table, values) => __awaiter(void 0, void 0, void 0, function* () {
-    const startTime = Date.now();
-    const valueFilters = [];
-    const propertiesToExcludeFromDb = ['ref'];
-    const safeValues = Object.keys(values).reduce((acc, key) => {
-        if (!propertiesToExcludeFromDb.includes(key)) {
-            acc[key] = values[key];
-        }
-        return acc;
-    }, {});
-    for (const [key, value] of Object.entries(safeValues)) {
-        let finalValue = value;
-        if (key === 'TObject') {
-            continue;
-        }
-        if (typeof value === 'object') {
-            finalValue = JSON.stringify(value);
-        }
-        const column = table[key];
-        if (!column) {
-            throw new Error(`Column not found for ${key}`);
-        }
-        if (typeof finalValue === 'undefined') {
-            finalValue = null;
-        }
-        if (finalValue === null) {
-            valueFilters.push(isNull(table[key]));
-            continue;
-        }
-        valueFilters.push(eq(table[key], finalValue));
+const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    if (!appDb) {
+        return new Promise((resolve) => {
+            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                const addresses = yield getAddressesFromDb();
+                resolve(addresses);
+            }), 500);
+        });
     }
-    const doneWithFilters = Date.now();
-    // console.log('valueFilters:', valueFilters)
-    // for ( const filter of valueFilters ) {
-    //   console.log('filter:', Object.keys(filter))
-    // }
-    // Build a query to find the record based on properties
-    const existingRecords = yield db
-        .select()
-        .from(table)
-        .where(and(...valueFilters));
-    const doneWithExistingRecords = Date.now();
-    if (existingRecords.length > 1) {
-        throw new Error('Multiple records found');
-    }
-    if (existingRecords.length > 0) {
-        // If record exists, update it
-        yield db
-            .update(table)
-            .set(safeValues)
-            .where(and(...valueFilters));
-        console.log('updatedRecord:', Object.assign(Object.assign({}, existingRecords[0]), safeValues));
-        const doneWithUpdate = Date.now();
-        console.log('[helpers/db] [createOrUpdate] filters duration:', doneWithFilters - startTime);
-        console.log('[helpers/db] [createOrUpdate] existingRecords duration:', doneWithExistingRecords - doneWithFilters);
-        console.log('[helpers/db] [createOrUpdate] update duration:', doneWithUpdate - doneWithExistingRecords);
-        return existingRecords[0];
-    }
-    else {
-        // If no record exists, create a new one
-        const newRecord = yield db.insert(table).values(safeValues).returning();
-        console.log('newRecord:', newRecord);
-        return newRecord[0];
-    }
-});
-const addModelsToInternalDb = (db, models$1) => __awaiter(void 0, void 0, void 0, function* () {
-    for (const [modelName, modelClass] of Object.entries(models$1)) {
-        console.log('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
-        const modelRecord = yield createOrUpdate(db, models, {
-            name: modelName,
-        });
-        for (let [propertyName, propertyValues] of Object.entries(modelClass.schema)) {
-            if (!propertyValues) {
-                throw new Error(`Property values not found for ${propertyName}`);
-            }
-            propertyValues.name = propertyName;
-            propertyValues.modelId = modelRecord.id;
-            for (let [key, value] of Object.entries(propertyValues)) {
-                if (key === 'ref') {
-                    const refModel = yield createOrUpdate(db, models, {
-                        name: value,
-                    });
-                    // delete propertyValues.ref
-                    propertyValues.refModelId = refModel.id;
-                }
-            }
-            const propertyRecord = yield createOrUpdate(db, properties, propertyValues);
-            console.log('propertyRecord:', propertyRecord);
-        }
-        console.log('[helpers/db] [addModelsToInternalDb] done modelName:', modelName);
-    }
-});
-const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
-    const seedDb = getDb(DB_NAME_SEED);
-    if (!seedDb) {
-        return new Promise((resolve) => {
-            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
-                const addresses = yield getAddressesFromDb();
-                resolve(addresses);
-            }), 500);
-        });
-    }
-    const appStatesRecords = yield seedDb
+    const appStatesRecords = yield appDb
         .select()
         .from(appState)
         .where(eq(appState.key, 'addresses'))
@@ -1518,7 +924,7 @@ const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* ()
     return JSON.parse(addressArrayString);
 });
 
-const logger$j = debug('app:property:actors:hydrateFromDb');
+const logger$m = debug('app:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, itemModelName, } = context;
     let propertyName = propertyNameRaw;
@@ -1586,23 +992,23 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         const firstRow = rows[0];
         const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, refResolvedValue, refResolvedDisplayValue, } = firstRow;
         if (propertyName && !propertyNameFromDb) {
-            logger$j(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
+            logger$m(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
         }
         if (propertyName &&
             propertyNameFromDb &&
             !propertyNameFromDb.includes(propertyName) &&
             !propertyName.includes(propertyNameFromDb) &&
             propertyNameFromDb !== propertyName) {
-            logger$j(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
+            logger$m(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
         }
         if (propertyValue && propertyValueFromDb !== propertyValue) {
-            logger$j(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
+            logger$m(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
         }
         if (seedLocalIdFromDb !== seedLocalId) {
-            logger$j(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
+            logger$m(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
         }
         if (seedUidFromDb !== seedUid) {
-            logger$j(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
+            logger$m(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
         }
         sendBack({
             type: 'updateContext',
@@ -1617,7 +1023,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             renderValue: refResolvedDisplayValue,
         });
         if (propertyNameFromDb === 'storageTransactionId') {
-            const { Item } = yield import('./index-Cgo0-c0n.js');
+            const { Item } = yield import('./index-scU0pJvR.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1635,7 +1041,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                         const renderValue = yield fs.promises
                             .readFile(htmlFilePath, 'utf8')
                             .catch((error) => {
-                            logger$j('Error reading html file', error);
+                            logger$m('Error reading html file', error);
                         });
                         property
                             .getService()
@@ -1716,7 +1122,7 @@ const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seed
 
 const eventEmitter = new EventEmitter();
 
-const logger$i = debug('app:write');
+const logger$l = debug('app:write');
 const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
     if (!modelName || (!seedLocalId && !seedUid)) {
         return;
@@ -1794,7 +1200,7 @@ const deleteItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoca
 });
 const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function* ({ propertyLocalId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, }) {
     if (!propertyLocalId && !seedLocalId) {
-        logger$i(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$l(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -1833,7 +1239,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
         const schemaUid = mostRecentRecord[9];
         const easDataType = mostRecentRecord[10];
         if (propertyValueFromDb === newValue) {
-            logger$i(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$l(`[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
@@ -1929,6 +1335,76 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
     sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
 });
 
+var MachineIds;
+(function (MachineIds) {
+    MachineIds["GLOBAL"] = "@seedSdk/global";
+    MachineIds["INTERNAL"] = "@seedSdk/internal";
+    MachineIds["DB"] = "@seedSdk/db";
+    MachineIds["EAS"] = "@seedSdk/eas";
+    MachineIds["ITEM"] = "@seedSdk/item";
+    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
+    MachineIds["MODEL"] = "@seedSdk/model";
+    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
+})(MachineIds || (MachineIds = {}));
+const { INTERNAL, DB, GLOBAL, EAS, MODEL } = MachineIds;
+var GlobalState;
+(function (GlobalState) {
+    GlobalState["UNINITIALIZED"] = "uninitialized";
+    GlobalState["INITIALIZING"] = "initializing";
+    GlobalState["INITIALIZED"] = "initialized";
+    GlobalState["GETTING_SEED_CLASS"] = "gettingSeedClass";
+    GlobalState["GETTING_SCHEMA_FOR_MODEL"] = "gettingSchemaForModel";
+    GlobalState["GETTING_TABLE_FOR_MODEL"] = "gettingTableForModel";
+    GlobalState["GETTING_MODEL_CLASS"] = "gettingModelClass";
+    GlobalState["ADDING_MODELS_TO_DB"] = "addingModelsToDb";
+})(GlobalState || (GlobalState = {}));
+const { UNINITIALIZED: UNINITIALIZED$1, INITIALIZING: INITIALIZING$1, INITIALIZED: INITIALIZED$1, GETTING_SEED_CLASS: GETTING_SEED_CLASS$1, GETTING_SCHEMA_FOR_MODEL: GETTING_SCHEMA_FOR_MODEL$1, GETTING_TABLE_FOR_MODEL, GETTING_MODEL_CLASS, ADDING_MODELS_TO_DB: ADDING_MODELS_TO_DB$1, } = GlobalState;
+var InternalState;
+(function (InternalState) {
+    InternalState["IDLE"] = "idle";
+    InternalState["INITIALIZING"] = "initializing";
+    InternalState["VALIDATING_INPUT"] = "validatingInput";
+    InternalState["CONFIGURING_FS"] = "configuringFs";
+    InternalState["LOADING_SEED_DB"] = "loadingSeedDb";
+    InternalState["SAVING_CONFIG"] = "savingConfig";
+    InternalState["LOADING_APP_DB"] = "loadingAppDb";
+    InternalState["LOADING_SDK_DB"] = "loadingSdkDb";
+})(InternalState || (InternalState = {}));
+const { VALIDATING_INPUT: VALIDATING_INPUT$1, CONFIGURING_FS: CONFIGURING_FS$1, LOADING_SEED_DB, LOADING_APP_DB: LOADING_APP_DB$1 } = InternalState;
+var DbState;
+(function (DbState) {
+    DbState["CHECKING_STATUS"] = "checkingStatus";
+    DbState["WAITING_FOR_FILES"] = "waitingForFiles";
+    DbState["VALIDATING"] = "validating";
+    DbState["CONNECTING_TO_DB"] = "connectingToDb";
+    // FETCHING_MIGRATIONS = 'fetchingMigrations',
+    DbState["MIGRATING"] = "migrating";
+})(DbState || (DbState = {}));
+const { CHECKING_STATUS: CHECKING_STATUS$1, VALIDATING: VALIDATING$1, CONNECTING_TO_DB: CONNECTING_TO_DB$1, WAITING_FOR_FILES: WAITING_FOR_FILES$1, MIGRATING: MIGRATING$1, } = DbState;
+const INTERNAL_VALIDATING_INPUT_SUCCESS = `${INTERNAL}.${VALIDATING_INPUT$1}.success`;
+const INTERNAL_CONFIGURING_FS_SUCCESS = `${INTERNAL}.${CONFIGURING_FS$1}.success`;
+const INTERNAL_LOADING_APP_DB_SUCCESS = `${INTERNAL}.${LOADING_APP_DB$1}.success`;
+const INTERNAL_SAVING_CONFIG_SUCCESS = `${INTERNAL}.savingConfig.success`;
+const GLOBAL_INITIALIZING_SEND_CONFIG = `${GLOBAL}.${INITIALIZING$1}.sendConfig`;
+const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY = `${GLOBAL}.${INITIALIZING$1}.internalServiceReady`;
+const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS = `${GLOBAL}.${ADDING_MODELS_TO_DB$1}.success`;
+const DB_CHECK_STATUS_UPDATE_PATHS = `${DB}.${CHECKING_STATUS$1}.updatePaths`;
+const DB_CHECK_STATUS_EXISTS = `${DB}.${CHECKING_STATUS$1}.exists`;
+const DB_VALIDATING_SUCCESS = `${DB}.${VALIDATING$1}.success`;
+const DB_VALIDATING_WAIT = `${DB}.${VALIDATING$1}.wait`;
+const DB_MIGRATING_WAIT = `${DB}.${MIGRATING$1}.wait`;
+const DB_MIGRATING_SUCCESS = `${DB}.${MIGRATING$1}.success`;
+const DB_CREATING_SUCCESS = `${DB}.${CONNECTING_TO_DB$1}.success`;
+const DB_WAITING_FOR_FILES_RECEIVED = `${DB}.${WAITING_FOR_FILES$1}.filesReceived`;
+const DB_ON_SNAPSHOT = `${DB}.onSnapshot`;
+const CHILD_SNAPSHOT = 'childSnapshot';
+const DB_NAME_APP = 'app_db';
+const BROWSER_FS_TOP_DIR = 'app-files';
+const EAS_ENDPOINT = process.env.NEXT_PUBLIC_EAS_ENDPOINT ||
+    process.env.EAS_ENDPOINT ||
+    'https://optimism-sepolia.easscan.org/graphql';
+const ARWEAVE_HOST = process.env.NEXT_PUBLIC_ARWEAVE_HOST || 'permagate.io';
+
 const queryClient = new QueryClient({
     defaultOptions: {
         queries: {
@@ -2190,49 +1666,6 @@ const propertyMachine = setup({
     // },
 });
 
-const APP_DB_CONFIG = 'browser.app.db.config.ts';
-const SDK_DB_CONFIG = 'sdk.db.config.ts';
-const SEED_DB_CONFIG = 'browser.seed.db.config.ts';
-const SCHEMA_NJK = 'schema.njk';
-const SCHEMA_TS = 'schema.ts';
-const INTERNAL_DATA_TYPES = {
-    Text: {
-        eas: 'string',
-    },
-    Number: {
-        eas: 'uint8',
-    },
-    ImageSrc: {
-        eas: 'string',
-    },
-    Relation: {
-        eas: 'bytes32',
-    },
-    List: {
-        eas: 'bytes32[]',
-    },
-};
-const internalPropertyNames = [
-    'localId',
-    'uid',
-    'seedLocalId',
-    'seedUid',
-    'schemaUid',
-    'attestationCreatedAt',
-    'createdAt',
-    'updatedAt',
-    'versionsCount',
-    'lastVersionPublishedAt',
-    'versionLocalId',
-    'lastLocalUpdateAt',
-    'storageTransactionId',
-    'versionUid',
-    'refSeedType',
-    'refValueType',
-    'resolvedValue',
-    'resolvedDisplayValue',
-];
-
 const modelStore = new Map();
 const getModels = () => {
     return Object.fromEntries(modelStore);
@@ -2247,8 +1680,8 @@ const setModel = (modelName, model) => {
     modelStore.set(modelName, model);
 };
 
-var _a$1;
-const logger$h = debug('app:property:class');
+var _a$2;
+const logger$k = debug('app:property:class');
 const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
@@ -2256,7 +1689,7 @@ class ItemProperty {
     constructor({ propertyValue, seedUid, seedLocalId, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
         this._isRelation = false;
         this._isList = false;
-        this[_a$1] = true;
+        this[_a$2] = true;
         const ModelClass = getModel(itemModelName);
         if (!ModelClass) {
             throw new Error(`Model ${itemModelName} not found`);
@@ -2296,7 +1729,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$h('List property value is not JSON', e);
+                            logger$k('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -2358,7 +1791,7 @@ class ItemProperty {
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$h(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$k(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, uid } = props;
@@ -2494,11 +1927,11 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$h(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$k(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
-_a$1 = immerable;
+_a$2 = immerable;
 ItemProperty.instanceCache = new Map();
 
 const TPropertyDataType = Type.Union([
@@ -2562,7 +1995,7 @@ const List = (ref, reValueType) => PropertyConstructor(Property.List(ref, reValu
 const waitForDb = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
-            const appDb = getDb(DB_NAME_APP);
+            const appDb = getAppDb();
             if (appDb) {
                 clearInterval(interval);
                 resolve();
@@ -3206,8 +2639,8 @@ const getRelatedSeedsAndVersions = () => __awaiter(void 0, void 0, void 0, funct
     });
 });
 const syncDbWithEasHandler = debounce((_) => __awaiter(void 0, void 0, void 0, function* () {
-    const sdkConfigDb = getSdkDb();
-    const { modelSchemas, schemaStringToModelRecord, modelRecords } = yield getModelSchemas({ sdkConfigDb });
+    const appDb = getAppDb();
+    const { modelSchemas, schemaStringToModelRecord, modelRecords } = yield getModelSchemas({ sdkConfigDb: appDb });
     if (!modelSchemas ||
         !modelSchemas.schemas ||
         modelSchemas.schemas.length === 0) {
@@ -3220,7 +2653,7 @@ const syncDbWithEasHandler = debounce((_) => __awaiter(void 0, void 0, void 0, f
             throw new Error(`Model not found for schema ${modelSchema.schema}`);
         }
         schemaUids.push(modelSchema.id);
-        yield sdkConfigDb
+        yield appDb
             .insert(modelUids)
             .values({
             modelId: foundModel.id,
@@ -3228,7 +2661,7 @@ const syncDbWithEasHandler = debounce((_) => __awaiter(void 0, void 0, void 0, f
         })
             .onConflictDoNothing();
         yield processPropertiesFoundInDb({
-            sdkConfigDb,
+            sdkConfigDb: appDb,
             foundModel,
         });
     }
@@ -3696,6 +3129,26 @@ const itemMachineSingle = setup({
     },
 });
 
+const getItemsData = (modelName) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    const itemsData = (yield appDb
+        .select({
+        seedLocalId: seeds.localId,
+        seedUid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        modelName: sql `${modelName}`,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        versionsCount: count(versions.localId),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt),
+        lastLocalUpdateAt: max(versions.createdAt),
+    })
+        .from(seeds)
+        .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
+        .where(and(eq(seeds.type, modelName.toLowerCase()), or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0))))
+        .groupBy(seeds.localId));
+    return itemsData;
+});
+
 const getPropertiesForSeed = (seedLocalId, seedUid) => __awaiter(void 0, void 0, void 0, function* () {
     if (seedLocalId && !seedUid) {
         const seedQueryStatement = `SELECT uid
@@ -3783,7 +3236,7 @@ const getPropertiesForSeed = (seedLocalId, seedUid) => __awaiter(void 0, void 0,
     return propertiesData;
 });
 
-const logger$g = debug('app:db:queries:getItem');
+const logger$j = debug('app:db:queries:getItem');
 const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, seedUid, }) {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -3791,7 +3244,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$g('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$j('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -3846,10 +3299,10 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     return initObj;
 });
 
-var _a;
+var _a$1;
 class Item {
     constructor(initialValues) {
-        this[_a] = true;
+        this[_a$1] = true;
         this._propertiesSubject = new BehaviorSubject({});
         this.subscribe = (callback) => {
             return this._service.subscribe((snapshot) => {
@@ -4020,7 +3473,7 @@ class Item {
         this._service.stop();
     }
 }
-_a = immerable;
+_a$1 = immerable;
 Item.instanceCache = new Map();
 
 const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
@@ -4034,9 +3487,9 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
     let modelNameLowercase;
     let modelNamePlural;
     let queryVariables;
-    let sdkConfigDb;
+    let appDb;
     const _initialize = () => __awaiter(void 0, void 0, void 0, function* () {
-        sdkConfigDb = getSdkDb();
+        appDb = getAppDb();
         // const rows = await getItemsDataFromDb(modelName)
         //
         // if (rows && rows.length > 0) {
@@ -4086,7 +3539,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
         if (!modelSchema.id) {
             throw new Error(`No schema ID found for schema ${JSON.stringify(modelSchema)}`);
         }
-        const foundModels = yield sdkConfigDb
+        const foundModels = yield appDb
             .select({
             id: models.id,
             name: models.name,
@@ -4101,14 +3554,14 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
             sendBack({ type: 'modelNotFound', modelName });
             return;
         }
-        yield sdkConfigDb
+        yield appDb
             .insert(modelUids)
             .values({
             modelId: foundModel.id,
             uid: modelSchema.id,
         })
             .onConflictDoNothing();
-        const foundPropertiesDb = yield sdkConfigDb
+        const foundPropertiesDb = yield appDb
             .select({
             id: properties.id,
             name: properties.name,
@@ -4158,7 +3611,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
                     // TODO: We should create the schema here?
                     continue;
                 }
-                yield sdkConfigDb
+                yield appDb
                     .insert(propertyUids)
                     .values({
                     propertyId: foundProperty.id,
@@ -4167,10 +3620,6 @@ const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
                     .onConflictDoNothing();
             }
         }
-        const seedDb = getDb(DB_NAME_SEED);
-        if (!seedDb) {
-            throw new Error('Seed DB not found');
-        }
         const addresses = yield getAddressesFromDb();
         queryVariables = {
             where: {
@@ -4219,7 +3668,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$f = debug('app:allItemsActors:fetchSeeds');
+const logger$i = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -4229,7 +3678,7 @@ const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const _fetchSeeds = () => __awaiter(void 0, void 0, void 0, function* () {
         const queryKey = [`getSeeds${modelName}`];
         const cachedResults = queryClient.getQueryData(queryKey);
-        logger$f(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$i(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
         const results = yield queryClient.fetchQuery({
             queryKey,
             queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return easClient.request(GET_SEEDS, queryVariables); }),
@@ -4272,14 +3721,7 @@ const fetchVersions = fromCallback(({ sendBack, input: { context } }) => {
 
 const fetchRelatedItems = fromCallback(({ sendBack, input: { context } }) => {
     const { ModelClass, modelName } = context;
-    const sdkConfigDb = getSdkDb();
-    const seedDb = getDb(DB_NAME_SEED);
-    if (!sdkConfigDb) {
-        throw new Error('SDK DB not found');
-    }
-    if (!seedDb) {
-        throw new Error('Seed DB not found');
-    }
+    const appDb = getAppDb();
     const relatedProperties = new Map();
     const relatedVersionsBySeedUid = new Map();
     const schemaUidsByModelName = new Map();
@@ -4296,7 +3738,7 @@ const fetchRelatedItems = fromCallback(({ sendBack, input: { context } }) => {
         const addresses = yield getAddressesFromDb();
         // Get the models they point to from sdkConfigDb
         for (const [propertyName, propertyDef] of relatedProperties.entries()) {
-            const relatedModelQuery = yield sdkConfigDb
+            const relatedModelQuery = yield appDb
                 .select({
                 id: models.id,
                 name: models.name,
@@ -4800,555 +4242,540 @@ const getArweave = () => {
     });
 };
 
-const logger$e = debug('app:react:db');
-const useDbsAreReady = () => {
-    const [dbsAreReady, setDbsAreReady] = useState(false);
-    const update = useCallback(() => {
-        if (dbsAreReady) {
+const initSeedSync = () => {
+    if (isNode()) {
+        return {
+            Model,
+            Property,
+            ImageSrc,
+            List,
+            Text,
+            Json,
+            Relation,
+            withSeed: withSeed$1,
+        };
+    }
+    else {
+        return {
+            Model,
+            Property,
+            ImageSrc,
+            Relation,
+            Text,
+            List,
+            Json,
+        };
+    }
+};
+
+const logger$h = debug('app:services:global:actors:initialize');
+const initialize = fromCallback(({ sendBack, input: { event, context } }) => {
+    const { internalService, models, endpoints } = context;
+    const { addresses } = event;
+    let environment = 'browser';
+    if (isNode()) {
+        environment = 'node';
+    }
+    if (isReactNative()) {
+        environment = 'react-native';
+    }
+    let internalSubscription;
+    if (environment === 'browser' && models) {
+        const _initFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
             return;
-        }
-        setDbsAreReady(true);
-    }, []);
-    useEffect(() => {
-        let globalSubscription;
-        let internalSubscription;
-        const _waitForDbs = () => __awaiter(void 0, void 0, void 0, function* () {
-            const globalService = getGlobalService();
-            const internalService = globalService.getSnapshot().context.internalService;
-            if (!internalService) {
-                logger$e('[useDbsAreReady] [useEffect] no internalService');
-                globalSubscription = globalService.subscribe(({ context }) => {
-                    if (!internalSubscription && context && context.internalService) {
-                        globalSubscription === null || globalSubscription === void 0 ? void 0 : globalSubscription.unsubscribe();
-                        internalSubscription = context.internalService.subscribe((snapshot) => {
-                            if (snapshot.value === 'ready') {
-                                update();
-                                internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-                            }
-                        });
+            // return new Promise((resolve) => {
+            // })
+        });
+        const _initInternal = () => __awaiter(void 0, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                internalSubscription = internalService.subscribe((snapshot) => {
+                    logger$h('[sdk] [internal] snapshot', snapshot);
+                    if (snapshot.value === 'ready') {
+                        resolve();
                     }
                 });
-                return;
-            }
-            const currentState = internalService.getSnapshot().value;
-            if (currentState === 'ready') {
-                update();
-                return;
-            }
-            internalSubscription = internalService.subscribe((snapshot) => {
-                if (snapshot.value === 'ready') {
-                    update();
-                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-                }
+                internalService.send({ type: 'init', endpoints, addresses });
             });
         });
-        _waitForDbs();
-        return () => {
-            if (globalSubscription) {
-                globalSubscription.unsubscribe();
-            }
-            if (internalSubscription) {
-                internalSubscription.unsubscribe();
-            }
-        };
-    }, []);
-    return {
-        dbsAreReady,
+        _initFileSystem().then(() => {
+            logger$h('[global/actors] File system initialized');
+        });
+        _initInternal().then(() => {
+            logger$h('[global/actors] Internal initialized');
+            sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
+            internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+        });
+        // _initEas().then(() => {
+        //   logger('EAS initialized')
+        // })
+    }
+    sendBack({ type: GLOBAL_INITIALIZING_SEND_CONFIG, environment });
+    return () => {
+        internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
     };
-};
+});
 
-const logger$d = debug('app:react:services');
-const finalStrings = ['idle', 'ready', 'done', 'success'];
-const getServiceName = (service) => {
-    let name = 'actor';
-    if (service && service.uniqueKey) {
-        name = service.uniqueKey;
-    }
-    if (service && !service.uniqueKey && service.logic && service.logic.config) {
-        name = getServiceUniqueKey(service);
-    }
-    return name;
-};
-const getServiceValue = (service) => {
-    let value;
-    if (service && service.getSnapshot() && service.getSnapshot().value) {
-        value = service.getSnapshot().value;
-    }
-    if (getServiceName(service) === 'global') {
-        if (value &&
-            typeof value === 'object' &&
-            Object.keys(value).length > 0 &&
-            Object.keys(value)[0] === 'initialized') {
-            value = 'ready';
-        }
+const logger$g = debug('app:services:global:actors:getSchemaForModel');
+const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { modelName } = event;
+    if (!modelName) {
+        console.warn('No modelName found');
+        return;
     }
-    return value;
-};
-const getServiceUniqueKey = (service) => {
-    if (!service || !service.logic || !service.logic.config) {
+    const { models } = context;
+    if (!models) {
+        console.warn('No models found');
         return;
     }
-    const config = service.logic.config;
-    if (!config.id) {
-        return;
-    }
-    let uniqueKey = config.id;
-    if (config.id.includes('@seedSdk/')) {
-        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
-    }
-    let snapshot;
-    try {
-        snapshot = service.getSnapshot();
-    }
-    catch (error) {
-        logger$d('Error:', error);
-        return uniqueKey;
+    const model = Object.entries(models).find(([modelNameFromConfig]) => modelNameFromConfig === modelName);
+    if (!model) {
+        throw new Error(`Model ${modelName} not found`);
     }
-    if (snapshot) {
-        const context = snapshot.context;
-        if (context && context.dbName) {
-            uniqueKey = context.dbName;
-        }
-        if (context && context.modelNamePlural) {
-            uniqueKey = context.modelNamePlural;
-        }
-        if (context && context.modelName) {
-            uniqueKey = pluralize(context.modelName.toLowerCase());
+    logger$g('[service/actor] [getSchemaForModel] model:', model);
+    sendBack({ type: 'schemaForModel', schema: model.schema });
+    return () => { };
+});
+
+const logger$f = debug('app:services:global:actors:addModelsToDb');
+const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
+    const { models: models$1 } = context;
+    const _addModelsToDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const appDb = getAppDb();
+        if (!models$1) {
+            return;
         }
-    }
-    return uniqueKey;
-};
-const useServices = () => {
-    const [actors, setActors] = useState([]);
-    const [percentComplete, setPercentComplete] = useState(5);
-    const actorsMap = new Map();
-    useEffect(() => {
-        const globalServiceListener = (event) => {
-            if (event && event.type === 'init') {
-                return;
+        const { models: SeedModels } = yield import('./seed.schema.config-CCYo8gj-.js');
+        const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
+        let hasModelsInDb = false;
+        const schemaDefsByModelName = new Map();
+        for (const [modelName, _] of Object.entries(allModels)) {
+            logger$f('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            let foundModel;
+            const foundModelsQuery = yield appDb
+                .select()
+                .from(models)
+                .where(eq(models.name, modelName));
+            if (!foundModelsQuery || foundModelsQuery.length === 0) {
+                yield appDb.insert(models).values({
+                    name: modelName,
+                });
+                logger$f('[global/actors] [addModelsToDb] inserted model:', modelName);
+                const foundModels = yield appDb
+                    .select({
+                    id: models.id,
+                    name: models.name,
+                    uid: modelUids.uid,
+                })
+                    .from(models)
+                    .leftJoin(modelUids, eq(models.id, modelUids.modelId))
+                    .where(eq(models.name, modelName))
+                    .limit(1);
+                foundModel = foundModels[0];
             }
-            if (event.actorRef &&
-                event.actorRef.logic &&
-                event.actorRef.logic.config) {
-                const uniqueKey = getServiceUniqueKey(event.actorRef);
-                if (!uniqueKey) {
-                    return;
-                }
-                event.actorRef.uniqueKey = uniqueKey;
-                actorsMap.set(uniqueKey, event.actorRef);
-                let actorsArray = Array.from(actorsMap.values());
-                actorsArray = orderBy(actorsArray, (a) => a.logic.config.id, ['asc']);
-                setActors(produce(actors, (draft) => {
-                    return actorsArray;
-                }));
+            if (foundModelsQuery && foundModelsQuery.length > 0) {
+                foundModel = foundModelsQuery[0];
             }
-        };
-        eventEmitter.addListener('inspect.globalService', globalServiceListener);
-        return () => {
-            eventEmitter.removeListener('inspect.globalService', globalServiceListener);
-        };
-    }, []);
-    useEffect(() => {
-        const globalService = actors.find((actor) => getServiceName(actor) === 'global');
-        const internalService = actors.find((actor) => getServiceName(actor) === 'internal');
-        if (!globalService || !internalService) {
-            return;
-        }
-        if (getServiceValue(globalService) === 'ready' &&
-            getServiceValue(internalService) === 'ready') {
-            const denominator = actors.length;
-            const finishedActors = actors.filter((actor) => {
-                const value = getServiceValue(actor);
-                return finalStrings.includes(value);
+            if (!foundModel) {
+                hasModelsInDb = false;
+                break;
+            }
+            schemaDefsByModelName.set(modelName, {
+                dbId: foundModel.id,
+                schemaDef: `bytes32 ${toSnakeCase(modelName)}`,
             });
-            const numerator = finishedActors.length;
-            const percentComplete = (numerator / denominator) * 100;
-            setPercentComplete(percentComplete);
         }
-    }, [actors]);
-    return {
-        services: actors,
-        percentComplete,
-    };
-};
-const useGlobalServiceStatus = () => {
-    const globalService = getGlobalService();
-    const status = useSelector(globalService, (snapshot) => {
-        return snapshot.value;
+        if (!hasModelsInDb) {
+            return false;
+        }
+        const schemaDefs = Array.from(schemaDefsByModelName.values()).map(({ schemaDef }) => schemaDef);
+        const { schemas } = yield queryClient.fetchQuery({
+            queryKey: [`getSchemasVersion`],
+            queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
+                return easClient.request(GET_SCHEMAS, {
+                    where: {
+                        schema: {
+                            in: schemaDefs,
+                        },
+                    },
+                });
+            }),
+        });
+        if (!schemas || schemas.length === 0) {
+            throw new Error(`No schemas found`);
+        }
+        for (const schema of schemas) {
+            const modelId = (_a = Array.from(schemaDefsByModelName.values()).find(({ schemaDef }) => schemaDef === schema.schema)) === null || _a === void 0 ? void 0 : _a.dbId;
+            if (!modelId) {
+                throw new Error(`No modelId found for schema ${schema.schema}`);
+            }
+            yield appDb
+                .insert(modelUids)
+                .values({
+                modelId,
+                uid: schema.id,
+            })
+                .onConflictDoNothing();
+        }
     });
-    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
-        if (!snapshot) {
-            return;
+    _addModelsToDb().then((hasModelsInDb) => {
+        sendBack({ type: GLOBAL_ADDING_MODELS_TO_DB_SUCCESS });
+        for (const [modelName, model] of Object.entries(models$1)) {
+            const service = context[`${modelName}Service`];
+            service.send({ type: 'modelsFound' });
         }
-        return snapshot.value;
+        eventEmitter.emit('syncDbWithEas');
+        return;
     });
-    useSelector(globalService, (snapshot) => {
-        return snapshot.context.internalService;
+    return () => { };
+});
+
+const logger$e = debug('app:services:db:actors:checkStatus');
+const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
+    const { dbName } = context;
+    logger$e('[db/actors] checkStatus context', context);
+    const pathToDir = `${BROWSER_FS_TOP_DIR}`;
+    const pathToDbDir = `${pathToDir}/db`;
+    const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
+    sendBack({
+        type: DB_CHECK_STATUS_UPDATE_PATHS,
+        pathToDb,
+        pathToDir,
+        pathToDbDir,
     });
-    return {
-        status,
-        internalStatus,
-    };
-};
+    const _checkStatus = () => __awaiter(void 0, void 0, void 0, function* () {
+        // logger('[db/actors] _checkStatus pathToDb', pathToDb)
+        // const exists = await fs.promises.exists(pathToJournal)
+        // if (exists) {
+        //   sendBack({
+        //     type: DB_CHECK_STATUS_EXISTS,
+        //   })
+        //   return
+        // }
+        //
+        // return new Promise((resolve) => {
+        //   sendBack({ type: DB_CHECK_STATUS_DOES_NOT_EXIST })
+        //
+        // })
+    });
+    _checkStatus().then(() => {
+        sendBack({ type: DB_CHECK_STATUS_EXISTS });
+        return;
+    });
+});
 
-const logger$c = debug('app:react:item');
-const useItem = ({ modelName, seedLocalId, seedUid }) => {
-    const [item, setItem] = useImmer(undefined);
-    const [itemSubscription, setItemSubscription] = useState();
-    const { status, internalStatus } = useGlobalServiceStatus();
-    const isReadingDb = useRef(false);
-    const itemStatus = useSelector(item === null || item === void 0 ? void 0 : item.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.value);
-    const updateItem = useCallback((newItem) => {
-        setItem(() => newItem);
-    }, []);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (isReadingDb.current ||
-            internalStatus !== 'ready' ||
-            (!seedUid && !seedLocalId)) {
+const logger$d = debug('app:services:db:actors:connectToDb');
+const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
+    logger$d('[db/actors] connectToDb context', context);
+    const { dbName, pathToDir } = context;
+    let isConnecting = false;
+    let dbId;
+    const _create = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (isConnecting) {
             return;
         }
-        isReadingDb.current = true;
-        const foundItem = yield Item.find({
-            modelName,
-            seedLocalId,
-            seedUid,
+        isConnecting = true;
+        let response;
+        const sqliteWasmClient = yield getSqliteWasmClient();
+        //@ts-ignore
+        response = yield sqliteWasmClient('config-get', {});
+        logger$d(response);
+        logger$d('Running SQLite3 version', response.result.version.libVersion);
+        //@ts-ignore
+        response = yield sqliteWasmClient('open', {
+            filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
         });
-        if (!foundItem) {
-            logger$c('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+        logger$d(response);
+        dbId = response.dbId;
+        // logger(`dbId: ${dbId}`)
+        logger$d('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
+    });
+    const interval = setInterval(() => {
+        // TODO: Add a timeout
+        // TODO: Add a cancel token to the promise so we can prevent more loops starting while we're checking the successful outcome
+        if (dbId) {
+            // logger(
+            //   '[db/actors] opening sqliteWasm connection with dbId:',
+            //   dbId,
+            // )
+            clearInterval(interval);
+            sendBack({ type: DB_CREATING_SUCCESS, dbId });
             return;
         }
-        updateItem(foundItem);
-        isReadingDb.current = false;
-    }), [internalStatus]);
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            readFromDb();
-        }
-    }, [internalStatus, status]);
-    useEffect(() => {
-        if (item && !itemSubscription) {
-            const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
-                const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
-                if (!newItem) {
-                    logger$c('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
-                    return;
-                }
-                setItem(() => newItem);
-            }));
-            setItemSubscription(subscription);
-        }
-        return () => {
-            itemSubscription === null || itemSubscription === void 0 ? void 0 : itemSubscription.unsubscribe();
-        };
-    }, [item, itemSubscription]);
-    useEffect(() => {
-        const seedId = seedUid || seedLocalId;
-        eventEmitter.addListener(`item.${modelName}.${seedId}.update`, readFromDb);
-        return () => {
-            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
-        };
-    }, []);
-    return {
-        item,
-        itemStatus,
-    };
-};
-const useItems = ({ modelName, options }) => {
-    const [items, setItems] = useImmer([]);
-    const [isReadingDb, setIsReadingDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const { dbsAreReady } = useDbsAreReady();
-    const modelNameRef = useRef(modelName);
-    const readFromDb = useCallback((event) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!event ||
-            !event.modelName ||
-            event.modelName !== modelNameRef.current ||
-            isReadingDb) {
-            return;
-        }
-        setIsReadingDb(true);
-        const allItems = yield Item.all(modelNameRef.current);
-        setItems(() => allItems);
-        setIsReadingDb(false);
-    }), [modelName]);
-    useEffect(() => {
-        if (dbsAreReady && !isInitialized) {
-            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
-                yield readFromDb({ modelName });
-                setIsInitialized(true);
-            });
-            _fetchItems();
-        }
-    }, [dbsAreReady, isInitialized]);
-    useEffect(() => {
-        eventEmitter.addListener('item.requestAll', readFromDb);
-        return () => {
-            eventEmitter.removeListener('item.requestAll');
-        };
-    }, []);
-    return {
-        items: orderBy(items, [
-            (item) => item.lastVersionPublishedAt ||
-                item.attestationCreatedAt ||
-                item.createdAt,
-        ], ['desc']).slice(0, 10),
-        isReadingDb,
-        isInitialized,
-    };
-};
-const useItemIsReady = () => {
-    const [itemListenersReady, setItemListenersReady] = useState(false);
-    const itemEventListenersHandler = useCallback((_) => {
-        setItemListenersReady(true);
-    }, []);
-    useEffect(() => {
-        const areReady = getAreItemEventHandlersReady();
-        if (areReady) {
-            itemEventListenersHandler(true);
-        }
-        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
-        return () => {
-            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
-        };
-    }, []);
-    return {
-        isReady: itemListenersReady,
-    };
-};
-const useCreateItem = (modelName) => {
-    const [isCreatingItem, setIsCreatingItem] = useState(false);
-    const { isReady } = useItemIsReady();
-    const createItem = useCallback((itemData) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!isReady) {
-            console.error(`[useCreateItem] [createItem] called before listeners are ready`, itemData);
-            return;
-        }
-        if (isCreatingItem) {
-            // TODO: should we setup a queue for this?
-            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
-            return;
-        }
-        setIsCreatingItem(true);
-        const { seedLocalId } = yield createNewItem(Object.assign({ modelName }, itemData));
-        yield Item.find({ modelName, seedLocalId });
-        eventEmitter.emit('item.requestAll', { modelName });
-        setIsCreatingItem(false);
-    }), [isCreatingItem, isReady]);
-    return {
-        createItem,
-        isCreatingItem,
-    };
-};
-const useDeleteItem = () => {
-    const [isDeletingItem, setIsDeletingItem] = useState(false);
-    const destroy = useCallback((item) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!item) {
-            return;
-        }
-        setIsDeletingItem(true);
-        const { modelName } = item.getService().getSnapshot().context;
-        yield deleteItem({ seedLocalId: item.seedLocalId });
-        eventEmitter.emit('item.requestAll', { modelName });
-        setIsDeletingItem(false);
-    }), [isDeletingItem]);
-    useEffect(() => { }, []);
-    return {
-        deleteItem: destroy,
-        isDeletingItem,
-    };
-};
-
-const logger$b = debug('app:react:property');
-const useItemProperty = (propertyName, seedLocalId) => {
-    const [property, setProperty] = useImmer(undefined);
-    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const { dbsAreReady } = useDbsAreReady();
-    const value = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => {
-        if (!snapshot || !snapshot.context) {
-            return;
-        }
-        return snapshot.context.renderValue || snapshot.context.propertyValue;
-    });
-    const status = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.value);
-    useEffect(() => {
-        if (dbsAreReady && property && property.value !== value) {
-            readFromDb();
-        }
-    }, [dbsAreReady, property, value]);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (!dbsAreReady && isReadingFromDb) {
-            return;
-        }
-        setIsReadingFromDb(true);
-        const foundProperty = yield ItemProperty.find({ propertyName, seedLocalId });
-        setIsReadingFromDb(false);
-        if (!foundProperty) {
-            logger$b(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
-            return;
-        }
-        setProperty(() => foundProperty);
-        setIsInitialized(true);
-    }), [dbsAreReady, isReadingFromDb]);
-    useEffect(() => {
-        readFromDb();
-    }, []);
-    // TODO: How can we force a re-render when the property is updated?
-    // Right now, the value will trigger an update because it's using a selector
-    // and a change is pushed to the hook listener.
-    return {
-        property,
-        isInitialized,
-        isReadingFromDb,
-        value,
-        status,
-    };
-};
-const useItemProperties = (item) => {
-    const [propertyObj, setPropertyObj] = useImmer({});
-    useState(false);
-    const updatePropertyObj = useCallback((event) => {
-        if (!item) {
-            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
-            return;
-        }
-        const { propertyName, propertyValue } = event;
-        if (!propertyName) {
+        _create()
+            .then(() => {
             return;
-        }
-        setPropertyObj((draft) => {
-            draft[propertyName] = propertyValue;
+        })
+            .catch((e) => {
+            isConnecting = false;
         });
-    }, [item]);
-    useEffect(() => {
-        if (!item) {
-            return;
+    }, 500);
+    return () => {
+        if (interval) {
+            clearInterval(interval);
         }
-        const eventKey = `item.${item.seedLocalId}.property.update`;
-        eventEmitter.addListener(eventKey, updatePropertyObj);
-        return () => {
-            eventEmitter.removeListener(eventKey, updatePropertyObj);
-        };
-    }, [item]);
-    return {
-        properties: propertyObj,
     };
-};
+});
 
-const logger$a = debug('app:global:actors');
-const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { models: models$1 } = context;
-    const _addModelsToDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        const sdkConfigDb = getSdkDb();
-        if (!models$1) {
-            return;
-        }
-        const { models: SeedModels } = yield import('./seed.schema.config-DYkIbj49.js');
-        const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
-        let hasModelsInDb = false;
-        const schemaDefsByModelName = new Map();
-        for (const [modelName, _] of Object.entries(allModels)) {
-            logger$a('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
-            let foundModel;
-            const foundModelsQuery = yield sdkConfigDb
-                .select()
-                .from(models)
-                .where(eq(models.name, modelName));
-            if (!foundModelsQuery || foundModelsQuery.length === 0) {
-                yield sdkConfigDb.insert(models).values({
-                    name: modelName,
+const validate = fromCallback(({ sendBack, input: { context } }) => {
+    const { pathToDir, pathToDb } = context;
+    const pathsToCheck = [
+        pathToDir,
+        `${pathToDir}/db`,
+        `${pathToDir}/db/meta`,
+        `${pathToDir}/db/meta/_journal.json`,
+    ];
+    const _validate = () => __awaiter(void 0, void 0, void 0, function* () {
+        // If any of the necessary files don't exist, we wipe them all and recreate
+        let exists = false;
+        for (const path of pathsToCheck) {
+            exists = yield fs.promises.exists(path);
+            if (!exists) {
+                sendBack({
+                    type: DB_VALIDATING_WAIT,
                 });
-                logger$a('[global/actors] [addModelsToDb] inserted model:', modelName);
-                const foundModels = yield sdkConfigDb
-                    .select({
-                    id: models.id,
-                    name: models.name,
-                    uid: modelUids.uid,
-                })
-                    .from(models)
-                    .leftJoin(modelUids, eq(models.id, modelUids.modelId))
-                    .where(eq(models.name, modelName))
-                    .limit(1);
-                foundModel = foundModels[0];
+                return false;
             }
-            if (foundModelsQuery && foundModelsQuery.length > 0) {
-                foundModel = foundModelsQuery[0];
-            }
-            if (!foundModel) {
-                hasModelsInDb = false;
-                break;
-            }
-            schemaDefsByModelName.set(modelName, {
-                dbId: foundModel.id,
-                schemaDef: `bytes32 ${toSnakeCase(modelName)}`,
-            });
         }
-        if (!hasModelsInDb) {
-            return false;
+        return exists;
+    });
+    _validate().then(() => {
+        sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir });
+        return;
+    });
+});
+
+const logger$c = debug('app:services:db:actors:migrate');
+const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void 0, [dbId_1, params_1, sql_1, dbName_1, ...args_1], void 0, function* (dbId, params, sql, dbName, retries = 2) {
+    const rowsToReturnRaw = [];
+    const sqliteWasmClient = yield getSqliteWasmClient();
+    // For a single exec command, the callback potentially gets called several times -- once for each row.
+    // So we need to collect all rows into a final array to return (execResult).
+    const rowsToReturn = yield new Promise((resolve, reject) => {
+        sqliteWasmClient('exec', {
+            dbId,
+            sql,
+            bind: params,
+            callback: (result) => {
+                // Checks if this is the final callback of the query
+                if (!result || !result.row || !result.rowNumber) {
+                    const returnResult = [];
+                    // Before returning the array, we process it to match the expected output format
+                    // const rowsToReturnProcessed = rowsToReturnRaw.reduce((acc, curr) => {
+                    //   if (
+                    //     Array.isArray(curr.row) &&
+                    //     curr.row?.length > 0 &&
+                    //     curr.columnNames.length > 0
+                    //   ) {
+                    //     const returnObj: ReturnObj = {
+                    //       database: dbName,
+                    //     }
+                    //
+                    //     const values = []
+                    //
+                    //     curr.columnNames.forEach((colName, index: number) => {
+                    //       if (curr.row && curr.row[index]) {
+                    //         returnObj[colName] = curr.row[index]
+                    //         values.push(curr.row[index])
+                    //       }
+                    //     })
+                    //     // rowsValueStrings.push(`(${values.join(', ')})`)
+                    //     acc.push(returnObj)
+                    //   }
+                    //   return acc
+                    // }, [] as string[])
+                    for (const currRow of rowsToReturnRaw) {
+                        // const values: string[] = []
+                        // currRow.columnNames.forEach((colName, index: number) => {
+                        //   if (currRow.row) {
+                        //     values.push(currRow.row[index])
+                        //   }
+                        // })
+                        // logger(`[db/actors] [dbExec] currRow`, currRow)
+                        returnResult.push(currRow.row);
+                    }
+                    resolve(returnResult);
+                }
+                else {
+                    // If not the final response, add this row to the return array
+                    rowsToReturnRaw.push(result);
+                }
+            },
+        }).catch((error) => __awaiter(void 0, void 0, void 0, function* () {
+            reject(error);
+        }));
+    });
+    // logger(`[db/actors] [dbExec] rowsToReturn`, rowsToReturn)
+    // logger(`[db/actors] [dbExec] rowsValues`, rowsValues)
+    return rowsToReturn || [];
+});
+const migrate = fromCallback(({ sendBack, input: { context } }) => {
+    const { pathToDbDir, dirName, dbId, dbName } = context;
+    logger$c('[db/actors] migrate context', context);
+    const schemaGlobString = `${BROWSER_FS_TOP_DIR}/${dirName}/schema/*`;
+    let journalExists = false;
+    // const _initFs = async (): Promise<void> => {
+    //   const handle = await navigator.storage.getDirectory()
+    //   // await configure({ backend: WebAccess, handle })
+    //   await configureSingle({
+    //     backend: WebAccess,
+    //     handle,
+    //   })
+    // }
+    //
+    // _initFs()
+    const _checkForFiles = () => __awaiter(void 0, void 0, void 0, function* () {
+        const { fs } = yield import('@zenfs/core');
+        journalExists = yield fs.promises.exists(`/${pathToDbDir}/meta/_journal.json`);
+        if (!journalExists) {
+            window.location.reload();
+            // setTimeout(() => {
+            //   _checkForFiles().then(() => {
+            //     return
+            //   })
+            // }, 500)
         }
-        const schemaDefs = Array.from(schemaDefsByModelName.values()).map(({ schemaDef }) => schemaDef);
-        const { schemas } = yield queryClient.fetchQuery({
-            queryKey: [`getSchemasVersion`],
-            queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
-                return easClient.request(GET_SCHEMAS, {
-                    where: {
-                        schema: {
-                            in: schemaDefs,
-                        },
-                    },
-                });
-            }),
+    });
+    const _migrate = () => __awaiter(void 0, void 0, void 0, function* () {
+        const drizzleDb = drizzle((sql, params, method) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                // logger(
+                //   `executing sql on ${dbName} with id: ${dbId} and method: ${method}`,
+                //   sql,
+                // )
+                const finalResult = yield dbExec(dbId, params, sql, dbName);
+                // logger(`finalResult with method: ${method}`, finalResult)
+                // Drizzle always waits for {rows: string[][]} or {rows: string[]} for the return value.
+                // When the method is get,  you should return a value as {rows: string[]}.
+                // Otherwise, you should return {rows: string[][]}.
+                return { rows: finalResult };
+            }
+            catch (e) {
+                console.error('Error from sqlite proxy server: ', JSON.stringify(e));
+                return { rows: [] };
+            }
+        }), {
+            schema: schemaGlobString,
+            // logger: true,
         });
-        if (!schemas || schemas.length === 0) {
-            throw new Error(`No schemas found`);
-        }
-        for (const schema of schemas) {
-            const modelId = (_a = Array.from(schemaDefsByModelName.values()).find(({ schemaDef }) => schemaDef === schema.schema)) === null || _a === void 0 ? void 0 : _a.dbId;
-            if (!modelId) {
-                throw new Error(`No modelId found for schema ${schema.schema}`);
+        const { migrate: drizzleMigrate } = yield import('drizzle-orm/sqlite-proxy/migrator');
+        const { readMigrationFiles } = yield import('drizzle-orm/migrator');
+        try {
+            const migrations = readMigrationFiles({
+                migrationsFolder: pathToDbDir,
+            });
+            if (migrations.length > 0) {
+                const incomingMigrationHashes = migrations.map((migration) => migration.hash);
+                let existingMigrationHashes;
+                let rows = [];
+                try {
+                    const query = yield drizzleDb.run(sql.raw(`SELECT hash, created_at
+               FROM main.__drizzle_migrations;`));
+                    rows = query.rows;
+                }
+                catch (e) {
+                    rows = [];
+                }
+                if (rows && rows.length > 0) {
+                    existingMigrationHashes = rows.map((row) => row[0]);
+                }
+                if (existingMigrationHashes) {
+                    let shouldRebuildDb = false;
+                    for (const existingHash of existingMigrationHashes) {
+                        if (!incomingMigrationHashes.includes(existingHash)) {
+                            shouldRebuildDb = true;
+                            break;
+                        }
+                    }
+                    if (shouldRebuildDb) {
+                        yield fs.promises.unlink(`${pathToDbDir}/${dbName}.sqlite3`);
+                    }
+                }
             }
-            yield sdkConfigDb
-                .insert(modelUids)
-                .values({
-                modelId,
-                uid: schema.id,
-            })
-                .onConflictDoNothing();
+            yield drizzleMigrate(drizzleDb, (queriesToRun) => __awaiter(void 0, void 0, void 0, function* () {
+                // logger('queriesToRun', queriesToRun)
+                for (const query of queriesToRun) {
+                    // logger('query', query)
+                    yield drizzleDb.run(sql.raw(query));
+                }
+            }), {
+                migrationsFolder: pathToDbDir,
+            });
+        }
+        catch (error) {
+            console.error('Error migrating database: ', error);
+            window.location.reload();
         }
+        setAppDb(drizzleDb);
+        // const createTempTableQuery = await appDb.run(
+        //   sql.raw(
+        //     `CREATE TEMP TABLE IF NOT EXISTS temp_last_inserted_id (id INTEGER, table TEXT);`,
+        //   ),
+        // )
+        //
+        // logger(
+        //   '[db/actors] [migrate] createTempTableQuery',
+        //   createTempTableQuery,
+        // )
+        // const triggersQuery = await appDb.run(
+        //   sql.raw(
+        //     `SELECT name
+        //      FROM main.sqlite_master
+        //      WHERE type = 'trigger';`,
+        //   ),
+        // )
+        //
+        // logger('[db/actors] [migrate] triggersQuery', triggersQuery)
+        //
+        // const triggers = triggersQuery.rows.map((row) => row[0])
+        //
+        // const tablesQuery = await appDb.run(
+        //   sql.raw(
+        //     `SELECT name
+        //      FROM main.sqlite_master
+        //      WHERE type = 'table';`,
+        //   ),
+        // )
+        //
+        // logger('[db/actors] [migrate] tablesQuery', tablesQuery)
+        //
+        // const tableNames = tablesQuery.rows.map((row) => row[0])
+        // logger('[db/actors] [migrate] tableNames', tableNames)
+        // for (const tableName of tableNames) {
+        //   const triggerName = `after_insert_${tableName}`
+        //   if (triggers.includes(triggerName)) {
+        //     continue
+        //   }
+        //           const createTriggerQuery = await appDb.run(
+        //             sql.raw(
+        //               `CREATE TRIGGER after_insert_${tableName}
+        // AFTER INSERT ON ${tableName}
+        // BEGIN
+        //     DELETE FROM temp_last_inserted_id;
+        //     INSERT INTO temp_last_inserted_id (id) VALUES (new.id);
+        // END;`,
+        //             ),
+        //           )
+        //
+        //           logger(
+        //             '[db/actors] [migrate] createTriggerQuery',
+        //             createTriggerQuery,
+        //           )
+        //         }
     });
-    _addModelsToDb().then((hasModelsInDb) => {
-        sendBack({ type: GLOBAL_ADDING_MODELS_TO_DB_SUCCESS });
-        for (const [modelName, model] of Object.entries(models$1)) {
-            const service = context[`${modelName}Service`];
-            service.send({ type: 'modelsFound' });
+    _checkForFiles()
+        .then(() => {
+        if (journalExists) {
+            return _migrate();
         }
-        eventEmitter.emit('syncDbWithEas');
-        return;
+    })
+        .then(() => {
+        sendBack({ type: DB_MIGRATING_SUCCESS, dbName });
     });
     return () => { };
 });
-const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { modelName } = event;
-    if (!modelName) {
-        console.warn('No modelName found');
-        return;
-    }
-    const { models } = context;
-    if (!models) {
-        console.warn('No models found');
-        return;
-    }
-    const model = Object.entries(models).find(([modelNameFromConfig]) => modelNameFromConfig === modelName);
-    if (!model) {
-        throw new Error(`Model ${modelName} not found`);
-    }
-    logger$a('[service/actor] [getSchemaForModel] model:', model);
-    sendBack({ type: 'schemaForModel', schema: model.schema });
-    return () => { };
-});
 
-const logger$9 = debug('app:services:db:machine');
+const logger$b = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -5369,7 +4796,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$9('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$b('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -5378,8 +4805,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$9('[db/machine] updateHasFiles event:', event);
-                    logger$9('[db/machine] updateHasFiles context:', context);
+                    logger$b('[db/machine] updateHasFiles event:', event);
+                    logger$b('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -5572,13 +4999,13 @@ class SqliteConnectionManager {
     }
 }
 
-const prepareDb = fromCallback(({ sendBack, input: { event, context } }) => {
+const prepareDb = fromCallback(({ sendBack }) => {
     let sqliteWasmClient;
     const _prepareDb = () => __awaiter(void 0, void 0, void 0, function* () {
         if (typeof window === 'undefined') {
             return;
         }
-        sqliteWasmClient = yield getSqlite();
+        sqliteWasmClient = yield getSqliteWasmClient();
     });
     const interval = setInterval(() => {
         // TODO: Add a timeout
@@ -5600,7 +5027,7 @@ const prepareDb = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$8 = debug('app:services:internal:helpers');
+const logger$a = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -5676,7 +5103,7 @@ const downloadFile = (url, localFilePath) => __awaiter(void 0, void 0, void 0, f
         if (JSON.stringify(error).includes('File exists')) {
             yield fs.promises.readFile(localFilePath, 'utf-8');
         }
-        logger$8(`[Error] Failed to download file from ${url}:`, error);
+        logger$a(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 });
@@ -5714,17 +5141,31 @@ const syncDbFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ filePat
     const fileList = yield fetchDirectory(filePaths);
     yield fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
     yield confirmFilesExist(fileList);
-    logger$8('[syncDbFiles] Files synced!');
+    logger$a('[syncDbFiles] Files synced!');
 });
 
-const logger$7 = debug('app:files:download');
+const logger$9 = debug('app:files:download');
 const downloadAllFilesRequestHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ endpoints, eventId, }) {
     yield syncDbFiles(endpoints);
     eventEmitter.emit('fs.downloadAll.success', { eventId });
     eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
 });
 const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, void 0, function* () {
-    const addresses = yield getAddressesFromDb();
+    let addresses;
+    if (isAppDbReady()) {
+        addresses = yield getAddressesFromDb();
+    }
+    if (!isAppDbReady()) {
+        const globalService = getGlobalService();
+        const internalService = globalService.getSnapshot().context.internalService;
+        if (internalService) {
+            yield waitFor(internalService, (snapshot) => snapshot.value === 'ready');
+            addresses = yield getAddressesFromDb();
+        }
+    }
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
     const { filesMetadata } = yield queryClient.fetchQuery({
         queryKey: ['getFilesMetadata', ...addresses],
         queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
@@ -5756,15 +5197,15 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
     if (!(yield fs.promises.exists('/files/images'))) {
         yield fs.promises.mkdir('/files/images', { recursive: true });
     }
-    const seedDb = getDb(DB_NAME_SEED);
-    if (!seedDb) {
+    const appDb = getAppDb();
+    if (!appDb) {
         console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available');
         return [];
     }
     for (const fileMetadata of filesMetadata) {
         const json = JSON.parse(fileMetadata.decodedDataJson);
         const transactionId = json[0].value.value;
-        const excludedTransactionsQuery = yield seedDb
+        const excludedTransactionsQuery = yield appDb
             .select()
             .from(appState)
             .where(eq(appState.key, 'excludedTransactions'));
@@ -5787,9 +5228,9 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
         try {
             const res = yield fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
             if (res.status !== 200) {
-                logger$7(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$9(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
-                yield writeAppState(seedDb, 'excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
+                yield writeAppState(appDb, 'excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
             }
             const dataString = yield arweave.transactions
@@ -5801,7 +5242,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 console.error(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`, error);
             });
             if (!dataString) {
-                logger$7(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
+                logger$9(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
             let contentType = identifyString(dataString);
             if (contentType !== 'json' &&
@@ -5809,7 +5250,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 contentType !== 'html') {
                 const possibleImageType = getImageDataType(dataString);
                 if (!possibleImageType) {
-                    logger$7(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    logger$9(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
                 }
                 contentType = possibleImageType;
@@ -5872,7 +5313,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             }
         }
         catch (error) {
-            logger$7(error);
+            logger$9(error);
         }
     }
 });
@@ -5918,15 +5359,14 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$6 = debug('app:internal:actors:configureFs');
+const logger$8 = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
-    const { endpoints, seedDbService, appDbService, sdkDbService } = context;
-    logger$6('[internal/actors] [configureFs] Configuring FS');
-    const services = [seedDbService, appDbService, sdkDbService];
+    const { endpoints, appDbService } = context;
+    logger$8('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$6('[internal/actors] [configureFs] calling _configureFs');
-        logger$6('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$6('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$8('[internal/actors] [configureFs] calling _configureFs');
+        logger$8('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$8('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         yield waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -5936,29 +5376,26 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
                 eventLabel: 'fs.downloadAll.success',
             },
         });
-        yield Promise.all(services.map((service) => __awaiter(void 0, void 0, void 0, function* () {
-            const { dirName } = service.getSnapshot().context;
-            const journalPath = `${BROWSER_FS_TOP_DIR}/${dirName}/db/meta/_journal.json`;
-            const journalExists = yield fs.promises.exists(journalPath);
-            if (journalExists) {
-                service.send({ type: DB_WAITING_FOR_FILES_RECEIVED });
-            }
-            // return new Promise<void>((resolve) => {
-            //   const interval = setInterval(() => {
-            //     journalExistsSync = fs.existsSync(journalPath)
-            //     logger(
-            //       '[internal/actors] [configureFs] journalExistsSync:',
-            //       journalExistsSync,
-            //     )
-            //     if (journalExistsSync) {
-            //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
-            //       clearInterval(interval)
-            //       resolve()
-            //     }
-            //   }, 200)
-            // })
-        })));
-        logger$6('[internal/actors] [configureFs] fs configured!');
+        const journalPath = `${BROWSER_FS_TOP_DIR}/db/meta/_journal.json`;
+        const journalExists = yield fs.promises.exists(journalPath);
+        if (journalExists) {
+            appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED });
+        }
+        // return new Promise<void>((resolve) => {
+        //   const interval = setInterval(() => {
+        //     journalExistsSync = fs.existsSync(journalPath)
+        //     logger(
+        //       '[internal/actors] [configureFs] journalExistsSync:',
+        //       journalExistsSync,
+        //     )
+        //     if (journalExistsSync) {
+        //       service.send({ type: DB_WAITING_FOR_FILES_RECEIVED })
+        //       clearInterval(interval)
+        //       resolve()
+        //     }
+        //   }, 200)
+        // })
+        logger$8('[internal/actors] [configureFs] fs configured!');
     });
     // Some of our dependencies use fs sync functions, which don't work with
     // OPFS. ZenFS creates an async cache of all files so that the sync functions
@@ -5971,33 +5408,8 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const loadSeedDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { seedDbService } = context;
-    if (seedDbService.getSnapshot().value === 'ready') {
-        sendBack({ type: INTERNAL_LOADING_SEED_DB_SUCCESS });
-        return () => { };
-    }
-    let subscription;
-    const _loadSeedDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        yield waitFor(seedDbService, (snapshot) => snapshot.value === 'ready');
-        subscription = seedDbService.subscribe({
-            next: (snapshot) => {
-                sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_SEED, snapshot });
-            },
-        });
-    });
-    _loadSeedDb().then(() => {
-        sendBack({ type: INTERNAL_LOADING_SEED_DB_SUCCESS });
-    });
-    return () => {
-        if (subscription) {
-            subscription.unsubscribe();
-        }
-    };
-});
-
-const logger$5 = debug('app:services:internal:actors:saveConfig');
-const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
+const logger$7 = 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({
@@ -6011,16 +5423,16 @@ const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
     }
     const _saveConfig = () => __awaiter(void 0, void 0, void 0, function* () {
         // logger('[sdk] [internal/actors] starting _saveConfig')
-        const seedDb = getDb(DB_NAME_SEED);
-        if (!seedDb) {
-            throw new Error('Seed DB not found');
+        const appDb = getAppDb();
+        if (!appDb) {
+            throw new Error('App DB not found');
         }
         const endpointsValueString = JSON.stringify(endpoints);
         const addressesValueString = JSON.stringify(addresses);
         // TODO: Figure out how to define on conflict with multiple rows added
         try {
             // logger('[sdk] [internal/actors] Saving endpoints to db')
-            yield seedDb
+            yield appDb
                 .insert(appState)
                 .values({
                 key: 'endpoints',
@@ -6034,7 +5446,7 @@ const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
                 setWhere: sql `key = 'endpoints'`,
             });
             // logger('[sdk] [internal/actors] Saving addresses to db')
-            yield seedDb
+            yield appDb
                 .insert(appState)
                 .values({
                 key: 'addresses',
@@ -6047,20 +5459,20 @@ const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
                 },
                 setWhere: sql `key = 'addresses'`,
             });
-            logger$5('[sdk] [internal/actors] Should be done saving');
+            logger$7('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     });
     _saveConfig().then(() => {
-        logger$5('[sdk] [internal/actors] Successfully saved config');
+        logger$7('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$4 = debug('app:services:internal:actors:loadAppDb');
+const logger$6 = debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -6081,42 +5493,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$4('[sdk] [internal/actors] Successfully loaded app DB');
-    });
-    return () => {
-        if (subscription) {
-            subscription.unsubscribe();
-        }
-    };
-});
-
-const logger$3 = debug('app:internal:actors:loadSdkDb');
-const loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { sdkDbService } = context;
-    logger$3('[sdk] [internal/actors] Loading SDK DB');
-    let subscription;
-    const _loadSdkDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        return new Promise((resolve) => {
-            if (sdkDbService.getSnapshot().value === 'ready') {
-                return resolve();
-            }
-            subscription = sdkDbService.subscribe({
-                next: (snapshot) => {
-                    if (snapshot.value === 'ready') {
-                        return resolve();
-                    }
-                    sendBack({
-                        type: DB_ON_SNAPSHOT,
-                        dbName: DB_NAME_SDK_CONFIG,
-                        snapshot,
-                    });
-                },
-            });
-        });
-    });
-    _loadSdkDb().then(() => {
-        sendBack({ type: INTERNAL_LOADING_SDK_DB_SUCCESS });
-        logger$3('[sdk] [internal/actors] Successfully loaded SDK DB');
+        logger$6('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -6125,11 +5502,11 @@ const loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$2 = debug('app:services:internal:machine');
+const logger$5 = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
-const { IDLE, VALIDATING_INPUT, SAVING_CONFIG, CONFIGURING_FS, LOADING_DBS, LOADING_SEED_DB, LOADING_APP_DB, LOADING_SDK_DB, } = InternalState;
+const { IDLE, VALIDATING_INPUT, SAVING_CONFIG, CONFIGURING_FS, LOADING_APP_DB, } = InternalState;
 // Create the state machine
 const internalMachine = setup({
     types: {
@@ -6140,10 +5517,8 @@ const internalMachine = setup({
         prepareDb,
         validateInput,
         configureFs,
-        loadSeedDb,
-        saveConfig,
         loadAppDb,
-        loadSdkDb,
+        saveConfig,
     },
 }).createMachine({
     id: MachineIds.INTERNAL,
@@ -6158,27 +5533,10 @@ const internalMachine = setup({
                 init: {
                     target: VALIDATING_INPUT,
                     actions: [
-                        assign({
-                            seedDbService: ({ spawn }) => spawn(dbMachine, {
-                                input: {
-                                    dbName: DB_NAME_SEED,
-                                    dirName: DB_DIR_NAME_SEED,
-                                },
-                            }),
-                        }),
                         assign({
                             appDbService: ({ spawn }) => spawn(dbMachine, {
                                 input: {
                                     dbName: DB_NAME_APP,
-                                    dirName: DB_DIR_NAME_APP,
-                                },
-                            }),
-                        }),
-                        assign({
-                            sdkDbService: ({ spawn }) => spawn(dbMachine, {
-                                input: {
-                                    dbName: DB_NAME_SDK_CONFIG,
-                                    dirName: DB_DIR_NAME_SDK,
                                 },
                             }),
                         }),
@@ -6224,7 +5582,7 @@ const internalMachine = setup({
         [CONFIGURING_FS]: {
             on: {
                 [INTERNAL_CONFIGURING_FS_SUCCESS]: {
-                    target: LOADING_SEED_DB,
+                    target: LOADING_APP_DB,
                     actions: assign({ hasFiles: true }),
                 },
             },
@@ -6238,32 +5596,24 @@ const internalMachine = setup({
             },
             tags: ['loading'],
         },
-        // We run this before the other DBs because it holds the config we need to
-        // rebuild. If we get interrupted after this then we don't have to start
-        // from scratch.
-        [LOADING_SEED_DB]: {
+        [LOADING_APP_DB]: {
             on: {
-                [INTERNAL_LOADING_SEED_DB_SUCCESS]: SAVING_CONFIG,
-                // [DB_ON_SNAPSHOT]: {
-                //   actions: emit(({ event: { snapshot } }) => {
-                //     return { type: CHILD_SNAPSHOT, snapshot }
-                //   }),
-                // },
+                [INTERNAL_LOADING_APP_DB_SUCCESS]: {
+                    target: SAVING_CONFIG,
+                    actions: () => {
+                        logger$5('[sdk] [internal/index] App DB loaded!');
+                    },
+                },
             },
             invoke: {
-                src: 'loadSeedDb',
+                src: 'loadAppDb',
                 input: ({ context, event }) => ({ context, event }),
             },
-            meta: {
-                displayText: 'Loading seed database',
-                percentComplete: 50,
-            },
-            tags: ['loading'],
         },
         // Save developer's config to DB
         [SAVING_CONFIG]: {
             on: {
-                [INTERNAL_SAVING_CONFIG_SUCCESS]: LOADING_DBS,
+                [INTERNAL_SAVING_CONFIG_SUCCESS]: 'ready',
             },
             invoke: {
                 src: 'saveConfig',
@@ -6275,77 +5625,9 @@ const internalMachine = setup({
             },
             tags: ['loading'],
         },
-        // The DBs can be loaded in parallel since they are independent of each other
-        [LOADING_DBS]: {
-            type: 'parallel',
-            states: {
-                [LOADING_APP_DB]: {
-                    initial: 'loading',
-                    states: {
-                        loading: {
-                            on: {
-                                [INTERNAL_LOADING_APP_DB_SUCCESS]: {
-                                    target: 'appDbLoaded',
-                                    actions: () => {
-                                        logger$2('[sdk] [internal/index] App DB loaded!');
-                                    },
-                                },
-                            },
-                            invoke: {
-                                src: 'loadAppDb',
-                                input: ({ context, event }) => ({ context, event }),
-                            },
-                        },
-                        appDbLoaded: {
-                            type: 'final',
-                            entry: () => {
-                                logger$2('[sdk] [internal/index] Entered appDbLoaded!');
-                            },
-                        },
-                    },
-                },
-                [LOADING_SDK_DB]: {
-                    initial: 'loading',
-                    states: {
-                        loading: {
-                            on: {
-                                [INTERNAL_LOADING_SDK_DB_SUCCESS]: {
-                                    target: 'sdkConfigDbLoaded',
-                                    actions: () => {
-                                        logger$2('[sdk] [internal/index] SDK Config DB loaded!');
-                                    },
-                                },
-                            },
-                            invoke: {
-                                src: 'loadSdkDb',
-                                input: ({ context, event }) => ({ context, event }),
-                            },
-                        },
-                        sdkConfigDbLoaded: {
-                            type: 'final',
-                            entry: () => {
-                                logger$2('[sdk] [internal/index] Entered sdkConfigDbLoaded!');
-                            },
-                        },
-                    },
-                },
-            },
-            onDone: {
-                target: 'ready',
-                actions: () => {
-                    logger$2('[sdk] [internal/index] All DBs loaded! Should be headed to ready');
-                    eventEmitter.emit('allDbsLoaded');
-                },
-            },
-            meta: {
-                displayText: 'Loading databases',
-                percentComplete: 90,
-            },
-            tags: ['loading'],
-        },
         ready: {
             entry: () => {
-                logger$2('[sdk] [internal/index] Ready!');
+                logger$5('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -6360,7 +5642,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$2('[sdk] [internal/index] Error!');
+                logger$5('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -6370,53 +5652,39 @@ const internalMachine = setup({
         },
     },
 });
-
-const logger$1 = debug('app:global:actors');
-const initialize = fromCallback(({ sendBack, input: { event, context } }) => {
-    const { internalService, models, endpoints } = context;
-    const { addresses } = event;
-    let environment = 'browser';
-    if (isNode()) {
-        environment = 'node';
-    }
-    if (isReactNative()) {
-        environment = 'react-native';
-    }
-    let internalSubscription;
-    if (environment === 'browser' && models) {
-        const _initFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
-            return;
-            // return new Promise((resolve) => {
-            // })
-        });
-        const _initInternal = () => __awaiter(void 0, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                internalSubscription = internalService.subscribe((snapshot) => {
-                    logger$1('[sdk] [internal] snapshot', snapshot);
-                    if (snapshot.value === 'ready') {
-                        resolve();
-                    }
-                });
-                internalService.send({ type: 'init', endpoints, addresses });
-            });
-        });
-        _initFileSystem().then(() => {
-            logger$1('[global/actors] File system initialized');
-        });
-        _initInternal().then(() => {
-            logger$1('[global/actors] Internal initialized');
-            sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
-            internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-        });
-        // _initEas().then(() => {
-        //   logger('EAS initialized')
-        // })
-    }
-    sendBack({ type: GLOBAL_INITIALIZING_SEND_CONFIG, environment });
-    return () => {
-        internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-    };
-});
+// const internalService = createActor(internalMachine, {
+//   input: {},
+//   inspect: (inspEvent) => {
+//     if (inspEvent.type === '@xstate.snapshot') {
+//       if (
+//         inspEvent.event &&
+//         inspEvent.event.snapshot &&
+//         inspEvent.event.snapshot.value
+//       ) {
+//         logger(
+//           `[internalService] ${inspEvent.event.snapshot.value}`,
+//           inspEvent,
+//         )
+//         return
+//       }
+//
+//       if (inspEvent.snapshot && inspEvent.snapshot.value) {
+//         logger(`[internalService] ${inspEvent.snapshot.value}`, inspEvent)
+//         return
+//       }
+//
+//       // logger(`[internalService] Uncaught event`, inspEvent)
+//     }
+//   },
+// })
+// internalService.subscribe((snapshot) => {
+//   globalService.send({ type: INTERNAL_SERVICE_SNAPSHOT, snapshot })
+// })
+//
+// internalService.on(CHILD_SNAPSHOT, (emitted) => {
+//   globalService.send({ ...emitted })
+// })
+// internalService.start()
 
 const { UNINITIALIZED, INITIALIZING, INITIALIZED, GETTING_SEED_CLASS, GETTING_SCHEMA_FOR_MODEL, ADDING_MODELS_TO_DB, } = GlobalState;
 createBrowserInspector({
@@ -6458,14 +5726,6 @@ const globalMachine = setup({
                                     },
                                 });
                             },
-                            // fileSystemService: ({ spawn, event }) => {
-                            //   return spawn(fileSystemMachine, {
-                            //     systemId: MachineIds.FILE_SYSTEM,
-                            //     input: {
-                            //       addresses: event.addresses,
-                            //     },
-                            //   })
-                            // },
                         }),
                         assign(({ event, spawn }) => {
                             const allItemsServices = {};
@@ -6549,11 +5809,11 @@ const globalMachine = setup({
                         (_a) => __awaiter(void 0, [_a], void 0, function* ({ context }) {
                             let SeedClass;
                             if (context.environment === 'node') {
-                                const { SeedNode } = yield import('./seed-DGCfCUOn.js');
+                                const { SeedNode } = yield import('./seed-Dpo8KWqz.js');
                                 SeedClass = SeedNode;
                             }
                             else {
-                                const { SeedBrowser } = yield import('./seed-BgRaREFr.js');
+                                const { SeedBrowser } = yield import('./seed-BDG7IW-o.js');
                                 SeedClass = SeedBrowser;
                             }
                             return SeedClass;
@@ -6647,6 +5907,444 @@ const globalService = createActor(globalMachine, {
 globalService.start();
 const getGlobalService = () => globalService;
 
+const logger$4 = debug('app:react:db');
+const useDbsAreReady = () => {
+    const [dbsAreReady, setDbsAreReady] = useState(false);
+    const update = useCallback(() => {
+        if (dbsAreReady) {
+            return;
+        }
+        setDbsAreReady(true);
+    }, []);
+    useEffect(() => {
+        let globalSubscription;
+        let internalSubscription;
+        const _waitForDbs = () => __awaiter(void 0, void 0, void 0, function* () {
+            const globalService = getGlobalService();
+            const internalService = globalService.getSnapshot().context.internalService;
+            if (!internalService) {
+                logger$4('[useDbsAreReady] [useEffect] no internalService');
+                globalSubscription = globalService.subscribe(({ context }) => {
+                    if (!internalSubscription && context && context.internalService) {
+                        globalSubscription === null || globalSubscription === void 0 ? void 0 : globalSubscription.unsubscribe();
+                        internalSubscription = context.internalService.subscribe((snapshot) => {
+                            if (snapshot.value === 'ready') {
+                                update();
+                                internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+                            }
+                        });
+                    }
+                });
+                return;
+            }
+            const currentState = internalService.getSnapshot().value;
+            if (currentState === 'ready') {
+                update();
+                return;
+            }
+            internalSubscription = internalService.subscribe((snapshot) => {
+                if (snapshot.value === 'ready') {
+                    update();
+                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+                }
+            });
+        });
+        _waitForDbs();
+        return () => {
+            if (globalSubscription) {
+                globalSubscription.unsubscribe();
+            }
+            if (internalSubscription) {
+                internalSubscription.unsubscribe();
+            }
+        };
+    }, []);
+    return {
+        dbsAreReady,
+    };
+};
+
+const logger$3 = debug('app:react:services');
+const finalStrings = ['idle', 'ready', 'done', 'success'];
+const getServiceName = (service) => {
+    let name = 'actor';
+    if (service && service.uniqueKey) {
+        name = service.uniqueKey;
+    }
+    if (service && !service.uniqueKey && service.logic && service.logic.config) {
+        name = getServiceUniqueKey(service);
+    }
+    return name;
+};
+const getServiceValue = (service) => {
+    let value;
+    if (service && service.getSnapshot() && service.getSnapshot().value) {
+        value = service.getSnapshot().value;
+    }
+    if (getServiceName(service) === 'global') {
+        if (value &&
+            typeof value === 'object' &&
+            Object.keys(value).length > 0 &&
+            Object.keys(value)[0] === 'initialized') {
+            value = 'ready';
+        }
+    }
+    if (value && typeof value === 'object') {
+        value = JSON.stringify(value);
+    }
+    return value;
+};
+const getServiceUniqueKey = (service) => {
+    if (!service || !service.logic || !service.logic.config) {
+        return;
+    }
+    const config = service.logic.config;
+    if (!config.id) {
+        return;
+    }
+    let uniqueKey = config.id;
+    if (config.id.includes('@seedSdk/')) {
+        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
+    }
+    let snapshot;
+    try {
+        snapshot = service.getSnapshot();
+    }
+    catch (error) {
+        logger$3('Error:', error);
+        return uniqueKey;
+    }
+    if (snapshot) {
+        const context = snapshot.context;
+        if (context && context.dbName) {
+            uniqueKey = context.dbName;
+        }
+        if (context && context.modelNamePlural) {
+            uniqueKey = context.modelNamePlural;
+        }
+        if (context && context.modelName) {
+            uniqueKey = pluralize(context.modelName.toLowerCase());
+        }
+    }
+    return uniqueKey;
+};
+const useServices = () => {
+    const [actors, setActors] = useState([]);
+    const [percentComplete, setPercentComplete] = useState(5);
+    const actorsMap = new Map();
+    useEffect(() => {
+        const globalServiceListener = (event) => {
+            if (event && event.type === 'init') {
+                return;
+            }
+            if (event.actorRef &&
+                event.actorRef.logic &&
+                event.actorRef.logic.config) {
+                const uniqueKey = getServiceUniqueKey(event.actorRef);
+                if (!uniqueKey) {
+                    return;
+                }
+                event.actorRef.uniqueKey = uniqueKey;
+                actorsMap.set(uniqueKey, event.actorRef);
+                let actorsArray = Array.from(actorsMap.values());
+                actorsArray = orderBy(actorsArray, (a) => a.logic.config.id, ['asc']);
+                setActors(produce(actors, (draft) => {
+                    return actorsArray;
+                }));
+            }
+        };
+        eventEmitter.addListener('inspect.globalService', globalServiceListener);
+        return () => {
+            eventEmitter.removeListener('inspect.globalService', globalServiceListener);
+        };
+    }, []);
+    useEffect(() => {
+        const globalService = actors.find((actor) => getServiceName(actor) === 'global');
+        const internalService = actors.find((actor) => getServiceName(actor) === 'internal');
+        if (!globalService || !internalService) {
+            return;
+        }
+        if (getServiceValue(globalService) === 'ready' &&
+            getServiceValue(internalService) === 'ready') {
+            const denominator = actors.length;
+            const finishedActors = actors.filter((actor) => {
+                const value = getServiceValue(actor);
+                return finalStrings.includes(value);
+            });
+            const numerator = finishedActors.length;
+            const percentComplete = (numerator / denominator) * 100;
+            setPercentComplete(percentComplete);
+        }
+    }, [actors]);
+    return {
+        services: actors,
+        percentComplete,
+    };
+};
+const useGlobalServiceStatus = () => {
+    const globalService = getGlobalService();
+    const status = useSelector(globalService, (snapshot) => {
+        return snapshot.value;
+    });
+    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
+        if (!snapshot) {
+            return;
+        }
+        return snapshot.value;
+    });
+    useSelector(globalService, (snapshot) => {
+        return snapshot.context.internalService;
+    });
+    return {
+        status,
+        internalStatus,
+    };
+};
+
+const logger$2 = debug('app:react:item');
+const useItem = ({ modelName, seedLocalId, seedUid }) => {
+    const [item, setItem] = useImmer(undefined);
+    const [itemSubscription, setItemSubscription] = useState();
+    const { status, internalStatus } = useGlobalServiceStatus();
+    const isReadingDb = useRef(false);
+    const itemStatus = useSelector(item === null || item === void 0 ? void 0 : item.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.value);
+    const updateItem = useCallback((newItem) => {
+        setItem(() => newItem);
+    }, []);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingDb.current ||
+            internalStatus !== 'ready' ||
+            (!seedUid && !seedLocalId)) {
+            return;
+        }
+        isReadingDb.current = true;
+        const foundItem = yield Item.find({
+            modelName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!foundItem) {
+            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            return;
+        }
+        updateItem(foundItem);
+        isReadingDb.current = false;
+    }), [internalStatus]);
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            readFromDb();
+        }
+    }, [internalStatus, status]);
+    useEffect(() => {
+        if (item && !itemSubscription) {
+            const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
+                const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
+                if (!newItem) {
+                    logger$2('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    return;
+                }
+                setItem(() => newItem);
+            }));
+            setItemSubscription(subscription);
+        }
+        return () => {
+            itemSubscription === null || itemSubscription === void 0 ? void 0 : itemSubscription.unsubscribe();
+        };
+    }, [item, itemSubscription]);
+    useEffect(() => {
+        const seedId = seedUid || seedLocalId;
+        eventEmitter.addListener(`item.${modelName}.${seedId}.update`, readFromDb);
+        return () => {
+            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
+        };
+    }, []);
+    return {
+        item,
+        itemStatus,
+    };
+};
+const useItems = ({ modelName, options }) => {
+    const [items, setItems] = useImmer([]);
+    const [isReadingDb, setIsReadingDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const { dbsAreReady } = useDbsAreReady();
+    const modelNameRef = useRef(modelName);
+    const readFromDb = useCallback((event) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!event ||
+            !event.modelName ||
+            event.modelName !== modelNameRef.current ||
+            isReadingDb) {
+            return;
+        }
+        setIsReadingDb(true);
+        const allItems = yield Item.all(modelNameRef.current);
+        setItems(() => allItems);
+        setIsReadingDb(false);
+    }), [modelName]);
+    useEffect(() => {
+        if (dbsAreReady && !isInitialized) {
+            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
+                yield readFromDb({ modelName });
+                setIsInitialized(true);
+            });
+            _fetchItems();
+        }
+    }, [dbsAreReady, isInitialized]);
+    useEffect(() => {
+        eventEmitter.addListener('item.requestAll', readFromDb);
+        return () => {
+            eventEmitter.removeListener('item.requestAll');
+        };
+    }, []);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']).slice(0, 10),
+        isReadingDb,
+        isInitialized,
+    };
+};
+const useItemIsReady = () => {
+    const [itemListenersReady, setItemListenersReady] = useState(false);
+    const itemEventListenersHandler = useCallback((_) => {
+        setItemListenersReady(true);
+    }, []);
+    useEffect(() => {
+        const areReady = getAreItemEventHandlersReady();
+        if (areReady) {
+            itemEventListenersHandler(true);
+        }
+        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
+        return () => {
+            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
+        };
+    }, []);
+    return {
+        isReady: itemListenersReady,
+    };
+};
+const useCreateItem = (modelName) => {
+    const [isCreatingItem, setIsCreatingItem] = useState(false);
+    const { isReady } = useItemIsReady();
+    const createItem = useCallback((itemData) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!isReady) {
+            console.error(`[useCreateItem] [createItem] called before listeners are ready`, itemData);
+            return;
+        }
+        if (isCreatingItem) {
+            // TODO: should we setup a queue for this?
+            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
+            return;
+        }
+        setIsCreatingItem(true);
+        const { seedLocalId } = yield createNewItem(Object.assign({ modelName }, itemData));
+        yield Item.find({ modelName, seedLocalId });
+        eventEmitter.emit('item.requestAll', { modelName });
+        setIsCreatingItem(false);
+    }), [isCreatingItem, isReady]);
+    return {
+        createItem,
+        isCreatingItem,
+    };
+};
+const useDeleteItem = () => {
+    const [isDeletingItem, setIsDeletingItem] = useState(false);
+    const destroy = useCallback((item) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!item) {
+            return;
+        }
+        setIsDeletingItem(true);
+        const { modelName } = item.getService().getSnapshot().context;
+        yield deleteItem({ seedLocalId: item.seedLocalId });
+        eventEmitter.emit('item.requestAll', { modelName });
+        setIsDeletingItem(false);
+    }), [isDeletingItem]);
+    useEffect(() => { }, []);
+    return {
+        deleteItem: destroy,
+        isDeletingItem,
+    };
+};
+
+const logger$1 = debug('app:react:property');
+const useItemProperty = (propertyName, seedLocalId) => {
+    const [property, setProperty] = useImmer(undefined);
+    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const { dbsAreReady } = useDbsAreReady();
+    const value = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => {
+        if (!snapshot || !snapshot.context) {
+            return;
+        }
+        return snapshot.context.renderValue || snapshot.context.propertyValue;
+    });
+    const status = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.value);
+    useEffect(() => {
+        if (dbsAreReady && property && property.value !== value) {
+            readFromDb();
+        }
+    }, [dbsAreReady, property, value]);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!dbsAreReady && isReadingFromDb) {
+            return;
+        }
+        setIsReadingFromDb(true);
+        const foundProperty = yield ItemProperty.find({ propertyName, seedLocalId });
+        setIsReadingFromDb(false);
+        if (!foundProperty) {
+            logger$1(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            return;
+        }
+        setProperty(() => foundProperty);
+        setIsInitialized(true);
+    }), [dbsAreReady, isReadingFromDb]);
+    useEffect(() => {
+        readFromDb();
+    }, []);
+    // TODO: How can we force a re-render when the property is updated?
+    // Right now, the value will trigger an update because it's using a selector
+    // and a change is pushed to the hook listener.
+    return {
+        property,
+        isInitialized,
+        isReadingFromDb,
+        value,
+        status,
+    };
+};
+const useItemProperties = (item) => {
+    const [propertyObj, setPropertyObj] = useImmer({});
+    useState(false);
+    const updatePropertyObj = useCallback((event) => {
+        if (!item) {
+            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
+            return;
+        }
+        const { propertyName, propertyValue } = event;
+        if (!propertyName) {
+            return;
+        }
+        setPropertyObj((draft) => {
+            draft[propertyName] = propertyValue;
+        });
+    }, [item]);
+    useEffect(() => {
+        if (!item) {
+            return;
+        }
+        const eventKey = `item.${item.seedLocalId}.property.update`;
+        eventEmitter.addListener(eventKey, updatePropertyObj);
+        return () => {
+            eventEmitter.removeListener(eventKey, updatePropertyObj);
+        };
+    }, [item]);
+    return {
+        properties: propertyObj,
+    };
+};
+
 const logger = debug('app:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
@@ -6657,5 +6355,326 @@ const setupServicesEventHandlers = () => {
     eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
 };
 
-export { useDeleteItem as $, APP_DB_CONFIG as A, setupFsListeners as B, CHILD_SNAPSHOT as C, DB_NAME_SDK_CONFIG as D, setupAllItemsEventHandlers as E, setupServicesEventHandlers as F, GET_SCHEMAS as G, globalService as H, Item as I, Json as J, getModel as K, List as L, Model as M, getModels as N, getModelNames as O, Property as P, areFsListenersReady as Q, Relation as R, SCHEMA_NJK as S, Text as T, ItemProperty as U, useItems as V, useItem as W, useItemProperties as X, useCreateItem as Y, useItemProperty as Z, __awaiter as _, GET_SEEDS as a, useServices as a0, getGlobalService as a1, getCorrectId as a2, GET_SEED_IDS as b, GET_STORAGE_TRANSACTION_ID as c, GET_VERSIONS as d, GET_PROPERTIES as e, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as f, itemMachineAll as g, internalMachine as h, itemMachineSingle as i, isNode as j, isBrowser as k, isReactNative as l, __decorate as m, __metadata as n, models as o, SCHEMA_TS as p, SDK_DB_CONFIG as q, SEED_DB_CONFIG as r, addModelsToInternalDb as s, ImageSrc as t, createNewMetadataFromExistingRecord as u, generateId as v, eventEmitter as w, getDb as x, DB_NAME_APP as y, setModel as z };
-//# sourceMappingURL=events-So24__c6.js.map
+const propertySaveHandler = (event) => __awaiter(void 0, void 0, void 0, function* () {
+    const { localId, seedLocalId, propertyName, propertyValue, seedUid, modelType, refSeedType, } = event;
+    const appDb = getAppDb();
+    if (!appDb) {
+        throw new Error('initialize: appDb is undefined');
+    }
+    if (!seedUid && !seedLocalId) {
+        throw new Error('seedUid and seedLocalId are both undefined');
+    }
+    if (seedUid && !seedLocalId) {
+        throw new Error("seedUid is defined but seedLocalId is not. This shouldn't happen since seedLocalIds are saved to the db at the same time as seedUid.");
+    }
+    let recordToUpdate;
+    let recordToUseAsSource;
+    let localRecordQuery;
+    const selectStatement = `SELECT local_id, uid, property_value, seed_local_id, seed_uid, created_at, attestation_created_at, schema_uid, model_type, version_local_id, version_uid, eas_data_type, ref_value_type, ref_schema_uid, ref_seed_type, ref_resolved_value, ref_resolved_display_value, attestation_raw`;
+    if (localId) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE local_id = '${localId}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && !seedLocalId && seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_uid = '${seedUid}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && seedLocalId && !seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_local_id = '${seedLocalId}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && seedLocalId && seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_local_id = '${seedLocalId}'
+           AND seed_uid = '${seedUid}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (localRecordQuery &&
+        localRecordQuery.rows &&
+        localRecordQuery.rows.length > 0) {
+        const propertyValueFromDb = localRecordQuery.rows[0][2];
+        if (propertyValueFromDb === propertyValue) {
+            // This should be a no-op since the property is already properly saved to the local db.
+            return;
+        }
+        const localIdFromDb = localRecordQuery.rows[0][0];
+        const uidFromDb = localRecordQuery.rows[0][1];
+        const shouldUpdate = !!localId || !uidFromDb;
+        const shouldCreateNew = !!localIdFromDb && !!uidFromDb;
+        if (shouldUpdate) {
+            recordToUpdate = {
+                localId: localId || localIdFromDb,
+            };
+        }
+        if (shouldCreateNew) {
+            recordToUseAsSource = {
+                localId: localIdFromDb,
+                uid: uidFromDb,
+                propertyValue: localRecordQuery.rows[0][2],
+                seedLocalId: localRecordQuery.rows[0][3],
+                seedUid: localRecordQuery.rows[0][4],
+                createdAt: localRecordQuery.rows[0][5],
+                attestationCreatedAt: localRecordQuery.rows[0][6],
+                schemaUid: localRecordQuery.rows[0][7],
+                modelType: localRecordQuery.rows[0][8],
+                versionLocalId: localRecordQuery.rows[0][9],
+                versionUid: localRecordQuery.rows[0][10],
+                easDataType: localRecordQuery.rows[0][11],
+                refValueType: localRecordQuery.rows[0][12],
+                refSchemaUid: localRecordQuery.rows[0][13],
+                refSeedType: localRecordQuery.rows[0][14],
+                refResolvedValue: localRecordQuery.rows[0][15],
+                refResolvedDisplayValue: localRecordQuery.rows[0][16],
+                attestationRaw: localRecordQuery.rows[0][17],
+            };
+        }
+    }
+    if (recordToUpdate) {
+        yield appDb.run(sql.raw(`UPDATE metadata
+         SET property_value = '${propertyValue}'
+         WHERE local_id = '${recordToUpdate.localId}';
+        `));
+    }
+    if (recordToUseAsSource) {
+        yield createNewMetadataFromExistingRecord({
+            existingRecord: recordToUseAsSource,
+            propertyName,
+            propertyValue,
+        });
+    }
+    if (!recordToUpdate && !recordToUseAsSource) {
+        const newLocalId = generateId();
+        yield appDb.run(sql.raw(`INSERT INTO metadata (local_id, seed_local_id, seed_uid, property_name, property_value, created_at, updated_at,
+                               model_type, ref_seed_type)
+         VALUES ('${newLocalId}', '${seedLocalId}', '${seedUid}', '${propertyName}', '${propertyValue}',
+                 ${Date.now()}, ${Date.now()}, '${modelType.toLowerCase()}',
+                 ${refSeedType ? `'${refSeedType.toLowerCase()}'` : 'NULL'});
+        `));
+    }
+    eventEmitter.emit(`property.${seedLocalId}.${propertyName}.save.response`, {
+        status: 'success',
+    });
+});
+
+const propertySaveRelationHandler = (event) => __awaiter(void 0, void 0, void 0, function* () {
+    const { localId, seedLocalId, propertyName, propertyValue, seedUid, modelType, refSeedType, } = event;
+    const appDb = getAppDb();
+    if (!appDb) {
+        throw new Error('initialize: appDb is undefined');
+    }
+    if (!seedUid && !seedLocalId) {
+        throw new Error('seedUid and seedLocalId are both undefined');
+    }
+    if (seedUid && !seedLocalId) {
+        throw new Error("seedUid is defined but seedLocalId is not. This shouldn't happen since seedLocalIds are saved to the db at the same time as seedUid.");
+    }
+    let recordToUpdate;
+    let recordToUseAsSource;
+    let localRecordQuery;
+    const selectStatement = `SELECT local_id, uid, property_value, seed_local_id, seed_uid, created_at, attestation_created_at, schema_uid, model_type, version_local_id, version_uid, eas_data_type, ref_value_type, ref_schema_uid, ref_seed_type, ref_resolved_value, ref_resolved_display_value, attestation_raw`;
+    if (localId) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE local_id = '${localId}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && !seedLocalId && seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_uid = '${seedUid}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && seedLocalId && !seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_local_id = '${seedLocalId}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (!localId && seedLocalId && seedUid) {
+        localRecordQuery = yield appDb.run(sql.raw(`${selectStatement}
+         FROM metadata
+         WHERE seed_local_id = '${seedLocalId}'
+           AND seed_uid = '${seedUid}'
+           AND property_name = '${propertyName}'
+         ORDER BY created_at DESC;
+        `));
+    }
+    if (localRecordQuery &&
+        localRecordQuery.rows &&
+        localRecordQuery.rows.length > 0) {
+        const propertyValueFromDb = localRecordQuery.rows[0][2];
+        if (propertyValueFromDb === propertyValue) {
+            // This should be a no-op since the property is already properly saved to the local db.
+            return;
+        }
+        const localIdFromDb = localRecordQuery.rows[0][0];
+        const uidFromDb = localRecordQuery.rows[0][1];
+        const shouldUpdate = !!localId || !uidFromDb;
+        const shouldCreateNew = !!localIdFromDb && !!uidFromDb;
+        if (shouldUpdate) {
+            recordToUpdate = {
+                localId: localId || localIdFromDb,
+            };
+        }
+        if (shouldCreateNew) {
+            recordToUseAsSource = {
+                localId: localIdFromDb,
+                uid: uidFromDb,
+                propertyValue: localRecordQuery.rows[0][2],
+                seedLocalId: localRecordQuery.rows[0][3],
+                seedUid: localRecordQuery.rows[0][4],
+                createdAt: localRecordQuery.rows[0][5],
+                attestationCreatedAt: localRecordQuery.rows[0][6],
+                schemaUid: localRecordQuery.rows[0][7],
+                modelType: localRecordQuery.rows[0][8],
+                versionLocalId: localRecordQuery.rows[0][9],
+                versionUid: localRecordQuery.rows[0][10],
+                easDataType: localRecordQuery.rows[0][11],
+                refValueType: localRecordQuery.rows[0][12],
+                refSchemaUid: localRecordQuery.rows[0][13],
+                refSeedType: localRecordQuery.rows[0][14],
+                refResolvedValue: localRecordQuery.rows[0][15],
+                refResolvedDisplayValue: localRecordQuery.rows[0][16],
+                attestationRaw: localRecordQuery.rows[0][17],
+            };
+        }
+    }
+    if (recordToUpdate) {
+        yield appDb.run(sql.raw(`UPDATE metadata
+         SET property_value = '${propertyValue}'
+         WHERE local_id = '${recordToUpdate.localId}';
+        `));
+    }
+    if (recordToUseAsSource) {
+        yield createNewMetadataFromExistingRecord({
+            existingRecord: recordToUseAsSource,
+            propertyName,
+            propertyValue,
+        });
+    }
+    if (!recordToUpdate && !recordToUseAsSource) {
+        const newSeedLocalId = generateId();
+        yield appDb.run(sql.raw(`INSERT INTO seeds (local_id, type, created_at, updated_at)
+         VALUES ('${newSeedLocalId}', '${refSeedType.toLowerCase()}', ${Date.now()}, ${Date.now()});
+        `));
+        const newVersionLocalId = generateId();
+        yield appDb.run(sql.raw(`INSERT INTO versions (local_id, seed_local_id, created_at, updated_at)
+         VALUES ('${newVersionLocalId}', '${newSeedLocalId}', ${Date.now()}, ${Date.now()});
+        `));
+        const newPropertyLocalId = generateId();
+        yield appDb.run(sql.raw(`INSERT INTO metadata (local_id, seed_local_id, version_local_id, property_name, property_value,
+                               ref_resolved_value, created_at,
+                               updated_at,
+                               model_type)
+         VALUES ('${newPropertyLocalId}', '${seedLocalId}', '${newVersionLocalId}', '${propertyName}',
+                 '${newSeedLocalId}', '${propertyValue}',
+                 ${Date.now()}, ${Date.now()}, '${modelType.toLowerCase()}');
+        `));
+    }
+    eventEmitter.emit(`property.${seedLocalId}.${propertyName}.saveRelation.response`, {
+        status: 'success',
+    });
+});
+
+const setupPropertyEventHandlers = () => {
+    eventEmitter.addListener('property.request', (event) => {
+        console.log('property.request', event);
+    });
+    eventEmitter.addListener('property.save.request', propertySaveHandler);
+    eventEmitter.addListener('property.saveRelation.request', propertySaveRelationHandler);
+};
+
+const client = {
+    init: ({ config, addresses }) => {
+        const { endpoints, models } = config;
+        for (const [key, value] of Object.entries(models)) {
+            setModel(key, value);
+        }
+        setupFsListeners();
+        setupAllItemsEventHandlers();
+        setupServicesEventHandlers();
+        setupPropertyEventHandlers();
+        if (areFsListenersReady()) {
+            eventEmitter.emit('fs.init');
+        }
+        if (!areFsListenersReady()) {
+            console.error('fs listeners not ready during init');
+        }
+        globalService.send({ type: 'init', endpoints, models, addresses });
+        import('./seed.schema.config-CCYo8gj-.js').then(({ models }) => {
+            for (const [key, value] of Object.entries(models)) {
+                setModel(key, value);
+            }
+        });
+    },
+    subscribe: (callback) => {
+        callback({
+            type: '@xstate.snapshot',
+            actorRef: globalService,
+            snapshot: globalService.getSnapshot(),
+        });
+        eventEmitter.addListener('globalService', callback);
+        return {
+            unsubscribe: () => {
+                eventEmitter.removeListener('globalService', callback);
+            },
+        };
+    },
+    on: (outerEvent, callback) => {
+        eventEmitter.addListener(outerEvent, callback);
+        return {
+            unsubscribe: () => {
+                eventEmitter.removeListener(outerEvent, callback);
+            },
+        };
+    },
+    getSeedClass: () => __awaiter(void 0, void 0, void 0, function* () {
+        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();
+    },
+};
+
+var _a;
+enableMapSet();
+let withSeed;
+if (isNode()) {
+    withSeed = (_a = initSeedSync()) === null || _a === void 0 ? void 0 : _a.withSeed;
+}
+
+export { CHILD_SNAPSHOT as C, GET_SCHEMAS as G, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, GET_SEEDS as a, GET_SEED_IDS as b, GET_STORAGE_TRANSACTION_ID as c, GET_VERSIONS as d, GET_PROPERTIES as e, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as f, itemMachineAll as g, internalMachine as h, itemMachineSingle as i, isNode as j, isBrowser as k, isReactNative as l, ImageSrc as m, ItemProperty as n, useItem as o, useItemProperties as p, useCreateItem as q, useItemProperty as r, useDeleteItem as s, useServices as t, useItems as u, getGlobalService as v, withSeed as w, client as x, getCorrectId as y };
+//# sourceMappingURL=index-D3JMvAuO.js.map