@seedprotocol/sdk 0.1.13 → 0.1.14

package/dist/{events-DbpQM9qG.js → events-DY-qRoqO.js}

@@ -1,28 +1,30 @@
-import { Type } from '@sinclair/typebox';
-import { useState, useEffect, useCallback, useRef } from 'react';
+import { useImmer } from 'use-immer';
+import { sql, count, max, eq, and, or, isNull, relations } from 'drizzle-orm';
+import { useState, useCallback, useEffect, useRef } from 'react';
+import debug from 'debug';
 import { fromCallback, setup, assign, createActor, waitFor, emit } from 'xstate';
 import { BehaviorSubject } from 'rxjs';
 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 debug from 'debug';
-import 'dayjs';
-import { customAlphabet } from 'nanoid';
-import * as nanoIdDictionary from 'nanoid-dictionary';
 import { startCase, debounce, camelCase, orderBy } from 'lodash-es';
-import { sqliteTable, text, int, blob, check, unique } from 'drizzle-orm/sqlite-core';
+import { immerable, produce } from 'immer';
+import pluralize from 'pluralize';
+import { useSelector } from '@xstate/react';
+import { orderBy as orderBy$1 } from 'lodash';
+import { createBrowserInspector } from '@statelyai/inspect';
+import 'reflect-metadata';
+import { Type } from '@sinclair/typebox';
+import Arweave from 'arweave';
+import { WebAccess } from '@zenfs/dom';
+import { drizzle } from 'drizzle-orm/sqlite-proxy';
 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 { immerable } from 'immer';
-import pluralize from 'pluralize';
-import { createBrowserInspector } from '@statelyai/inspect';
-import { WebAccess } from '@zenfs/dom';
-import Arweave from 'arweave';
-import { useImmer } from 'use-immer';
-import { useSelector } from '@xstate/react';
+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 EventEmitter from 'eventemitter3';
 
 const isNode = () => {
@@ -213,14 +215,14 @@ const getSqlite = async () => {
   }
 };
 
-const logger$e = debug('app:db:actors');
+const logger$g = debug('app:db:actors');
 let seedDb;
 let appDb;
 let sdkConfigDb;
 let sqliteWasmClient$1;
 const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     const { dbName, dirName } = context;
-    logger$e('[db/actors] checkStatus context', context);
+    logger$g('[db/actors] checkStatus context', context);
     const pathToDir = `${BROWSER_FS_TOP_DIR}/${dirName}`;
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
@@ -251,7 +253,7 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$e('[db/actors] connectToDb context', context);
+    logger$g('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     let isConnecting = false;
     let dbId;
@@ -266,16 +268,16 @@ const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
         }
         //@ts-ignore
         response = yield sqliteWasmClient$1('config-get', {});
-        logger$e(response);
-        logger$e('Running SQLite3 version', response.result.version.libVersion);
+        logger$g(response);
+        logger$g('Running SQLite3 version', response.result.version.libVersion);
         //@ts-ignore
         response = yield sqliteWasmClient$1('open', {
             filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
         });
-        logger$e(response);
+        logger$g(response);
         dbId = response.dbId;
         // logger(`dbId: ${dbId}`)
-        logger$e('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
+        logger$g('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
     });
     const interval = setInterval(() => {
         // TODO: Add a timeout
@@ -395,7 +397,7 @@ const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void
 });
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dirName, dbId, dbName } = context;
-    logger$e('[db/actors] migrate context', context);
+    logger$g('[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;
@@ -675,7 +677,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
     }
 });
 
-const logger$d = debug('app:shared:helpers');
+const logger$f = debug('app:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
     return customAlphabet(alphanumeric, 10)();
@@ -738,7 +740,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$d(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$f(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
     const uint = yield fs.promises.readFile(imageFilePath);
@@ -1517,7 +1519,7 @@ const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* ()
     return JSON.parse(addressArrayString);
 });
 
-const logger$c = debug('app:property:actors:hydrateFromDb');
+const logger$e = debug('app:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, itemModelName, } = context;
     let propertyName = propertyNameRaw;
@@ -1585,23 +1587,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$c(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
+            logger$e(`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$c(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
+            logger$e(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
         }
         if (propertyValue && propertyValueFromDb !== propertyValue) {
-            logger$c(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
+            logger$e(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
         }
         if (seedLocalIdFromDb !== seedLocalId) {
-            logger$c(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
+            logger$e(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
         }
         if (seedUidFromDb !== seedUid) {
-            logger$c(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
+            logger$e(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
         }
         sendBack({
             type: 'updateContext',
@@ -1616,7 +1618,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             renderValue: refResolvedDisplayValue,
         });
         if (propertyNameFromDb === 'storageTransactionId') {
-            const { Item } = yield import('./index-D2_skdGT.js');
+            const { Item } = yield import('./index-Do5zWGFy.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1634,7 +1636,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                         const renderValue = yield fs.promises
                             .readFile(htmlFilePath, 'utf8')
                             .catch((error) => {
-                            logger$c('Error reading html file', error);
+                            logger$e('Error reading html file', error);
                         });
                         property
                             .getService()
@@ -1715,7 +1717,7 @@ const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seed
 
 const eventEmitter = new EventEmitter();
 
-const logger$b = debug('app:write');
+const logger$d = debug('app:write');
 const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
     if (!modelName || (!seedLocalId && !seedUid)) {
         return;
@@ -1793,7 +1795,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$b(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$d(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -1832,7 +1834,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
         const schemaUid = mostRecentRecord[9];
         const easDataType = mostRecentRecord[10];
         if (propertyValueFromDb === newValue) {
-            logger$b(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$d(`[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
@@ -2247,7 +2249,7 @@ const setModel = (modelName, model) => {
 };
 
 var _a$1;
-const logger$a = debug('app:property:class');
+const logger$c = debug('app:property:class');
 const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
@@ -2295,7 +2297,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$a('List property value is not JSON', e);
+                            logger$c('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -2357,7 +2359,7 @@ class ItemProperty {
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$a(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$c(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, uid } = props;
@@ -2493,7 +2495,7 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$a(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$c(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
@@ -3782,7 +3784,7 @@ const getPropertiesForSeed = (seedLocalId, seedUid) => __awaiter(void 0, void 0,
     return propertiesData;
 });
 
-const logger$9 = debug('app:db:queries:getItem');
+const logger$b = 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');
@@ -3790,7 +3792,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$9('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$b('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -4218,7 +4220,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$8 = debug('app:allItemsActors:fetchSeeds');
+const logger$a = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -4228,7 +4230,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$8(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$a(`[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); }),
@@ -4799,1723 +4801,1831 @@ const getArweave = () => {
     });
 };
 
-const logger$7 = 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$7('[sdk] [internal] snapshot', snapshot);
-                    if (snapshot.value === 'ready') {
-                        resolve();
-                    }
-                });
-                internalService.send({ type: 'init', endpoints, addresses });
-            });
-        });
-        _initFileSystem().then(() => {
-            logger$7('[global/actors] File system initialized');
-        });
-        _initInternal().then(() => {
-            logger$7('[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 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) {
+const logger$9 = debug('app:react:db');
+const useDbsAreReady = () => {
+    const [dbsAreReady, setDbsAreReady] = useState(false);
+    const update = useCallback(() => {
+        if (dbsAreReady) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-Cz8esgav.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$7('[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,
+        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$9('[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();
+                            }
+                        });
+                    }
                 });
-                logger$7('[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];
-            }
-            if (foundModelsQuery && foundModelsQuery.length > 0) {
-                foundModel = foundModelsQuery[0];
+                return;
             }
-            if (!foundModel) {
-                hasModelsInDb = false;
-                break;
+            const currentState = internalService.getSnapshot().value;
+            if (currentState === 'ready') {
+                update();
+                return;
             }
-            schemaDefsByModelName.set(modelName, {
-                dbId: foundModel.id,
-                schemaDef: `bytes32 ${toSnakeCase(modelName)}`,
+            internalSubscription = internalService.subscribe((snapshot) => {
+                if (snapshot.value === 'ready') {
+                    update();
+                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+                }
             });
-        }
-        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}`);
+        _waitForDbs();
+        return () => {
+            if (globalSubscription) {
+                globalSubscription.unsubscribe();
             }
-            yield sdkConfigDb
-                .insert(modelUids)
-                .values({
-                modelId,
-                uid: schema.id,
-            })
-                .onConflictDoNothing();
-        }
-    });
-    _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' });
+            if (internalSubscription) {
+                internalSubscription.unsubscribe();
+            }
+        };
+    }, []);
+    return {
+        dbsAreReady,
+    };
+};
+
+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';
         }
-        eventEmitter.emit('syncDbWithEas');
-        return;
-    });
-    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 value;
+};
+const getServiceUniqueKey = (service) => {
+    if (!service || !service.logic || !service.logic.config) {
         return;
     }
-    const model = Object.entries(models).find(([modelNameFromConfig]) => modelNameFromConfig === modelName);
-    if (!model) {
-        throw new Error(`Model ${modelName} not found`);
+    const config = service.logic.config;
+    if (!config.id) {
+        return;
     }
-    logger$7('[service/actor] [getSchemaForModel] model:', model);
-    sendBack({ type: 'schemaForModel', schema: model.schema });
-    return () => { };
-});
-
-class SqliteConnectionManager {
-    constructor(sqliteModule, idleTimeout = 300000) {
-        // Default idle timeout: 5 minutes
-        this.sqliteModule = sqliteModule;
-        this.idleTimeout = idleTimeout;
-        this.databases = {};
-        this.idleTimers = {};
+    let uniqueKey = config.id;
+    if (config.id.includes('@seedSdk/')) {
+        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
     }
-    resetIdleTimer(dbName) {
-        if (this.idleTimers[dbName]) {
-            clearTimeout(this.idleTimers[dbName]);
+    const snapshot = service.getSnapshot();
+    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());
         }
-        this.idleTimers[dbName] = setTimeout(() => {
-            this.closeConnection(dbName);
-        }, this.idleTimeout);
     }
-    getConnection(dbName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.databases[dbName]) {
-                this.resetIdleTimer(dbName);
-                return this.databases[dbName];
-            }
-            const db = new this.sqliteModule();
-            yield db.open(dbName);
-            this.databases[dbName] = db;
-            this.resetIdleTimer(dbName);
-            return db;
-        });
-    }
-    execute(dbName_1, sql_1) {
-        return __awaiter(this, arguments, void 0, function* (dbName, sql, params = []) {
-            const db = yield this.getConnection(dbName);
-            const result = db.exec(sql, params);
-            this.resetIdleTimer(dbName);
-            return result;
-        });
-    }
-    closeConnection(dbName) {
-        if (this.databases[dbName]) {
-            this.databases[dbName].close();
-            delete this.databases[dbName];
-            if (this.idleTimers[dbName]) {
-                clearTimeout(this.idleTimers[dbName]);
-                delete this.idleTimers[dbName];
+    return uniqueKey;
+};
+const useServices = () => {
+    const [actors, setActors] = useState([]);
+    const [percentComplete, setPercentComplete] = useState(5);
+    const actorsMap = new Map();
+    useEffect(() => {
+        const globalServiceListener = (event) => {
+            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$1(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$6 = debug('app:services:internal:helpers');
-/**
- * Recursively create directories if they don't exist.
- * @param {string} dirPath - The directory path to create.
- */
-const createDirectories = (dirPath) => __awaiter(void 0, void 0, void 0, function* () {
-    const dirPathExists = yield fs.promises.exists(dirPath);
-    if (dirPathExists) {
-        return;
-    }
-    const parentDir = path.dirname(dirPath);
-    const parentDirExists = yield fs.promises.exists(parentDir);
-    if (!parentDirExists) {
-        yield createDirectories(parentDir);
-    }
-    yield fs.promises.mkdir(dirPath, { recursive: true });
-});
-let busy = false;
-const downloadFile = (url, localFilePath) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const response = yield fetch(url);
-        const fileData = yield response.text().catch((error) => {
-            console.error(`Failed to parse text from ${url}:`, error);
-        });
-        if (!fileData) {
-            console.error(`No file data from ${url}`);
+const logger$8 = 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;
         }
-        const localDirPath = path.dirname(localFilePath);
-        if (busy) {
+        isReadingDb.current = true;
+        const foundItem = yield Item.find({
+            modelName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!foundItem) {
+            logger$8('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
             return;
         }
-        busy = true;
-        yield createDirectories(localDirPath);
-        const filename = path.basename(localFilePath);
-        const regex = /(\d+)[\w_]+\.(sql|json)$/;
-        const match = filename.match(regex);
-        let migrationNumber;
-        if (match && match.length > 1) {
-            migrationNumber = match[1];
+        updateItem(foundItem);
+        isReadingDb.current = false;
+    }), [internalStatus]);
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            readFromDb();
         }
-        if (migrationNumber) {
-            const filesInDir = yield fs.promises.readdir(localDirPath);
-            for (const file of filesInDir) {
-                if (file === filename) {
-                    continue;
-                }
-                const innerMatch = file.match(regex);
-                let existingFileMigrationNumber;
-                if (innerMatch && innerMatch.length > 1) {
-                    existingFileMigrationNumber = innerMatch[1];
-                }
-                if (migrationNumber &&
-                    existingFileMigrationNumber &&
-                    existingFileMigrationNumber === migrationNumber) {
-                    yield fs.promises.unlink(path.join(localDirPath, file));
+    }, [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$8('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    return;
                 }
-            }
-        }
-        // if (filename === '_journal.json') {
-        //   const exists = await fs.promises.exists(localFilePath)
-        //   if (exists) {
-        //     await fs.promises.rm(localFilePath)
-        //   }
-        //   await fs.promises.writeFile(localFilePath, fileData)
-        // }
-        //
-        // if (filename !== '_journal.json') {
-        //   await fs.promises.writeFile(localFilePath, fileData)
-        // }
-        yield fs.promises.writeFile(localFilePath, fileData);
-    }
-    catch (error) {
-        if (JSON.stringify(error).includes('File exists')) {
-            yield fs.promises.readFile(localFilePath, 'utf-8');
+                setItem(() => newItem);
+            }));
+            setItemSubscription(subscription);
         }
-        logger$6(`[Error] Failed to download file from ${url}:`, error);
-    }
-    busy = false;
-});
-const fetchDirectory = (url) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield fetch(url);
-    return response.json();
-});
-const fetchFilesRecursively = (url, localPath, fileList) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        for (const file of fileList) {
-            const fileUrl = `${url}/${file}`;
-            const fileLocalPath = path.join(localPath, file);
-            // logger(`[fetchFilesRecursively] fileUrl: ${fileUrl}`)
-            // logger(`[fetchFilesRecursively] fileLocalPath: ${fileLocalPath}`)
-            yield downloadFile(fileUrl, fileLocalPath);
+        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;
         }
-    }
-    catch (error) {
-        console.error(`Failed to fetch files from ${url}:`, error);
-    }
-});
-const confirmFilesExist = (filePaths) => __awaiter(void 0, void 0, void 0, function* () {
-    let everythingDownloaded = false;
-    for (const filePath of filePaths) {
-        const fullPath = path.join(BROWSER_FS_TOP_DIR, filePath);
-        everythingDownloaded = yield fs.promises.exists(fullPath);
-    }
-    if (!everythingDownloaded) {
-        setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield confirmFilesExist(filePaths);
-        }), 500);
-    }
-});
-const syncDbFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ filePaths, files }) {
-    const fileList = yield fetchDirectory(filePaths);
-    yield fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
-    yield confirmFilesExist(fileList);
-    logger$6('[syncDbFiles] Files synced!');
-});
-
-const logger$5 = 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();
-    const { filesMetadata } = yield queryClient.fetchQuery({
-        queryKey: ['getFilesMetadata', ...addresses],
-        queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
-            return easClient.request(GET_FILES_METADATA, {
-                where: {
-                    attester: {
-                        in: addresses,
-                    },
-                    schema: {
-                        is: {
-                            id: {
-                                equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
-                            },
-                        },
-                    },
-                },
-            });
-        }),
-    });
-    if (!(yield fs.promises.exists('/files'))) {
-        yield fs.promises.mkdir('/files', { recursive: true });
-    }
-    if (!(yield fs.promises.exists('/files/html'))) {
-        yield fs.promises.mkdir('/files/html', { recursive: true });
-    }
-    if (!(yield fs.promises.exists('/files/json'))) {
-        yield fs.promises.mkdir('/files/json', { recursive: true });
-    }
-    if (!(yield fs.promises.exists('/files/images'))) {
-        yield fs.promises.mkdir('/files/images', { recursive: true });
-    }
-    const seedDb = getDb(DB_NAME_SEED);
-    if (!seedDb) {
-        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
-            .select()
-            .from(appState)
-            .where(eq(appState.key, 'excludedTransactions'));
-        let excludedTransactions = new Set();
-        if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
-            const valueString = excludedTransactionsQuery[0].value;
-            if (valueString) {
-                const excludedTransactionsArray = JSON.parse(valueString);
-                excludedTransactions = new Set(excludedTransactionsArray);
-            }
-        }
-        if (excludedTransactions.has(transactionId)) {
-            continue;
-        }
-        const arweave = getArweave();
-        if (!arweave) {
-            console.warn('[fetchAll/actors] [fetchAllBinaryData] arweave not available');
-            return [];
-        }
-        try {
-            const res = yield fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
-            if (res.status !== 200) {
-                logger$5(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
-                excludedTransactions.add(transactionId);
-                yield writeAppState(seedDb, 'excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
-                continue;
-            }
-            const dataString = yield arweave.transactions
-                .getData(transactionId, {
-                decode: true,
-                string: true,
-            })
-                .catch((error) => {
-                console.error(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`, error);
-            });
-            if (!dataString) {
-                logger$5(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
-            }
-            let contentType = identifyString(dataString);
-            if (contentType !== 'json' &&
-                contentType !== 'base64' &&
-                contentType !== 'html') {
-                const possibleImageType = getImageDataType(dataString);
-                if (!possibleImageType) {
-                    logger$5(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
-                    continue;
-                }
-                contentType = possibleImageType;
-            }
-            if (contentType === 'url') {
-                const url = dataString;
-                const response = yield fetch(url);
-                if (!response.ok) {
-                    throw new Error(`Failed to fetch image: ${response.statusText}`);
-                }
-                // Get the image as a Blob
-                const blob = yield response.blob();
-                const buffer = yield blob.arrayBuffer();
-                const bufferUint8Array = new Uint8Array(buffer);
-                // Extract the file extension from the URL
-                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
-                if (!extensionMatch) {
-                    throw new Error('Unable to determine the file extension from the URL.');
-                }
-                const fileExtension = extensionMatch[0]; // e.g., ".jpg"
-                // Set the file name (you can customize this)
-                // const fileNameFromUrl = `${transactionId}${fileExtension}`
-                yield fs.promises.writeFile(`/files/images/${transactionId}`, bufferUint8Array, {
-                    encoding: 'binary',
-                });
-                continue;
-            }
-            const mimeType = getMimeType(dataString);
-            let fileName = transactionId;
-            if (contentType === 'base64') {
-                if (mimeType) {
-                    fileName += `.${mimeType}`;
-                }
-                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
-                const base64Data = dataString.split(',').pop() || '';
-                // Decode the Base64 string to binary
-                const binaryString = atob(base64Data);
-                const length = binaryString.length;
-                const binaryData = new Uint8Array(length);
-                for (let i = 0; i < length; i++) {
-                    binaryData[i] = binaryString.charCodeAt(i);
-                }
-                yield fs.promises.writeFile(`/files/images/${fileName}`, binaryData, {
-                    encoding: 'binary',
-                });
-                // if (dataUint8Array && dataUint8Array instanceof Uint8Array) {
-                //   await fs.promises.writeFile(
-                //     `/files/images/${fileName}`,
-                //     dataUint8Array,
-                //   )
-                // }
-            }
-            if (contentType === 'html') {
-                fileName += '.html';
-                yield fs.promises.writeFile(`/files/html/${fileName}`, dataString);
-            }
-            if (contentType === 'json') {
-                fileName += '.json';
-                yield fs.promises.writeFile(`/files/json/${fileName}`, dataString);
-            }
-        }
-        catch (error) {
-            logger$5(error);
-        }
-    }
-});
-
-let isInitialized = false;
-const fsInitHandler = (_) => __awaiter(void 0, void 0, void 0, function* () {
-    if (isInitialized) {
-        eventEmitter.emit('fs.init.response', { success: true });
-        return;
-    }
-    try {
-        const handle = yield navigator.storage.getDirectory();
-        // await configure({ backend: WebAccess, handle })
-        yield configureSingle({
-            backend: WebAccess,
-            handle,
-        });
-        isInitialized = true;
-        eventEmitter.emit('fs.init.response', { success: true });
-    }
-    catch (e) {
-        if (!isInitialized) {
-            console.error('[fs.init] error initializing fs', e);
-            eventEmitter.emit('fs.init.response', {
-                success: false,
-                error: e,
+        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();
         }
-        // TODO: We can ignore this for now but should figure out if this is being called excessively
-    }
-});
-let areReady = false;
-const setupFsListeners = () => {
-    eventEmitter.addListener('fs.downloadAll.request', downloadAllFilesRequestHandler);
-    eventEmitter.addListener('fs.downloadAllBinary.request', downloadAllFilesBinaryRequestHandler);
-    eventEmitter.addListener('fs.init', fsInitHandler);
-    areReady = true;
-};
-const areFsListenersReady = () => {
-    return areReady;
-};
-const isFsInitialized = () => {
-    return isInitialized;
+    }, [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 logger$4 = debug('app:internal:actors');
-let sqliteWasmClient;
-let manager;
-const validateInput = fromCallback(({ sendBack, input: { event } }) => {
-    const { endpoints, addresses } = event;
-    if (typeof window === 'undefined') {
-        throw new Error('validateInput called from non-browser context');
-    }
-    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
-        throw new Error('validateInput called with invalid endpoints');
-    }
-    if (!addresses || !addresses.length) {
-        throw new Error('validateInput called with invalid addresses');
-    }
-    const _validateInput = () => __awaiter(void 0, void 0, void 0, function* () {
-        sendBack({
-            type: INTERNAL_VALIDATING_INPUT_SUCCESS,
-            endpoints,
-            addresses,
-        });
-    });
-    _validateInput().then(() => {
-        return;
-    });
-});
-const prepareDb = fromCallback(({ sendBack, input: { event, context } }) => {
-    const _prepareDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (typeof window === 'undefined') {
-            return;
+const useItemIsReady = () => {
+    const [itemListenersReady, setItemListenersReady] = useState(false);
+    const itemEventListenersHandler = useCallback((_) => {
+        setItemListenersReady(true);
+    }, []);
+    useEffect(() => {
+        const areReady = getAreItemEventHandlersReady();
+        if (areReady) {
+            itemEventListenersHandler(true);
         }
-        sqliteWasmClient = yield getSqlite();
-    });
-    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 (sqliteWasmClient) {
-            clearInterval(interval);
-            manager = new SqliteConnectionManager(sqliteWasmClient);
-            sendBack({ type: 'prepareDbSuccess', manager });
+        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;
         }
-        _prepareDb().then(() => {
+        if (isCreatingItem) {
+            // TODO: should we setup a queue for this?
+            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
             return;
-        });
-    }, 500);
-    return () => {
-        if (interval) {
-            clearInterval(interval);
         }
+        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 configureFs = fromCallback(({ sendBack, input: { context } }) => {
-    const { endpoints, seedDbService, appDbService, sdkDbService } = context;
-    logger$4('[internal/actors] [configureFs] Configuring FS');
-    const services = [seedDbService, appDbService, sdkDbService];
-    const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$4('[internal/actors] [configureFs] calling _configureFs');
-        logger$4('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$4('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
-        yield waitForEvent({
-            req: {
-                eventLabel: 'fs.downloadAll.request',
-                data: { endpoints },
-            },
-            res: {
-                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$4('[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
-    // work, but we have to wait for it to be built. Otherwise things like
-    // drizzleMigrate will fail since they can't see the migration files yet.
-    _configureFs().then(() => {
-        sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS });
-        return;
-    });
-    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 });
+};
+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$7 = 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;
     });
-    return () => {
-        if (subscription) {
-            subscription.unsubscribe();
+    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$7(`[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 saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
-    if (typeof window === 'undefined') {
-        console.error('seedInitBrowser called from non-browser context');
-        sendBack({
-            type: 'error',
-            error: 'Browser method called from non-browser context',
-        });
-    }
-    const { endpoints, addresses } = context;
-    if (!endpoints) {
-        throw new Error('saveConfig called with invalid endpoints');
-    }
-    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 useItemProperties = (item) => {
+    const [propertyObj, setPropertyObj] = useImmer({});
+    useState(false);
+    const updatePropertyObj = useCallback((event) => {
+        if (!item) {
+            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
+            return;
         }
-        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
-                .insert(appState)
-                .values({
-                key: 'endpoints',
-                value: endpointsValueString,
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: endpointsValueString,
-                },
-                setWhere: sql `key = 'endpoints'`,
-            });
-            // logger('[sdk] [internal/actors] Saving addresses to db')
-            yield seedDb
-                .insert(appState)
-                .values({
-                key: 'addresses',
-                value: addressesValueString,
-            })
-                .onConflictDoUpdate({
-                target: appState.key,
-                set: {
-                    value: addressesValueString,
-                },
-                setWhere: sql `key = 'addresses'`,
-            });
-            logger$4('[sdk] [internal/actors] Should be done saving');
+        const { propertyName, propertyValue } = event;
+        if (!propertyName) {
+            return;
         }
-        catch (error) {
-            console.error('Error saving config:', error);
+        setPropertyObj((draft) => {
+            draft[propertyName] = propertyValue;
+        });
+    }, [item]);
+    useEffect(() => {
+        if (!item) {
+            return;
         }
-    });
-    _saveConfig().then(() => {
-        logger$4('[sdk] [internal/actors] Successfully saved config');
-        return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
-    });
-    return () => { };
-});
-const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { appDbService } = context;
-    let subscription;
-    const _loadAppDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        return new Promise((resolve) => {
-            if (appDbService.getSnapshot().value === 'ready') {
-                return resolve();
-            }
-            subscription = appDbService.subscribe({
-                next: (snapshot) => {
+        const eventKey = `item.${item.seedLocalId}.property.update`;
+        eventEmitter.addListener(eventKey, updatePropertyObj);
+        return () => {
+            eventEmitter.removeListener(eventKey, updatePropertyObj);
+        };
+    }, [item]);
+    return {
+        properties: propertyObj,
+    };
+};
+
+const logger$6 = 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$6('[sdk] [internal] snapshot', snapshot);
                     if (snapshot.value === 'ready') {
-                        return resolve();
+                        resolve();
                     }
-                    sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot });
-                },
+                });
+                internalService.send({ type: 'init', endpoints, addresses });
             });
         });
-    });
-    _loadAppDb().then(() => {
-        sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$4('[sdk] [internal/actors] Successfully loaded app DB');
-    });
-    return () => {
-        if (subscription) {
-            subscription.unsubscribe();
-        }
+        _initFileSystem().then(() => {
+            logger$6('[global/actors] File system initialized');
+        });
+        _initInternal().then(() => {
+            logger$6('[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 loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { sdkDbService } = context;
-    logger$4('[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();
+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-t5AiIDm_.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$6('[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,
+                });
+                logger$6('[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];
             }
-            subscription = sdkDbService.subscribe({
-                next: (snapshot) => {
-                    if (snapshot.value === 'ready') {
-                        return resolve();
-                    }
-                    sendBack({
-                        type: DB_ON_SNAPSHOT,
-                        dbName: DB_NAME_SDK_CONFIG,
-                        snapshot,
-                    });
-                },
+            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;
+        }
+        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 sdkConfigDb
+                .insert(modelUids)
+                .values({
+                modelId,
+                uid: schema.id,
+            })
+                .onConflictDoNothing();
+        }
     });
-    _loadSdkDb().then(() => {
-        sendBack({ type: INTERNAL_LOADING_SDK_DB_SUCCESS });
-        logger$4('[sdk] [internal/actors] Successfully loaded SDK DB');
-    });
-    return () => {
-        if (subscription) {
-            subscription.unsubscribe();
+    _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' });
         }
-    };
+        eventEmitter.emit('syncDbWithEas');
+        return;
+    });
+    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$6('[service/actor] [getSchemaForModel] model:', model);
+    sendBack({ type: 'schemaForModel', schema: model.schema });
+    return () => { };
 });
 
-const logger$3 = debug('app:services:db:machine');
-const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
-const dbMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        checkStatus,
-        validate,
-        connectToDb,
-        migrate,
-    },
-}).createMachine({
-    id: MachineIds.DB,
-    initial: CHECKING_STATUS,
-    context: ({ input }) => input,
-    on: {
-        [DB_WAITING_FOR_FILES_RECEIVED]: {
-            actions: assign({
-                hasFiles: ({ event }) => {
-                    logger$3('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
-                    return true;
-                },
-            }),
-        },
-        updateHasFiles: {
-            target: `.${CHECKING_STATUS}`,
-            actions: assign({
-                hasFiles: ({ context, event }) => {
-                    logger$3('[db/machine] updateHasFiles event:', event);
-                    logger$3('[db/machine] updateHasFiles context:', context);
-                    return event.hasFiles;
-                },
-            }),
-        },
-    },
-    // always: {
-    //   target: `.${CHECKING_STATUS}`,
-    //   guard: ({ context, event }) => context.hasFiles && event.type === 'updateHasFiles',
-    // },
-    states: {
-        idle: {
-            on: {
-                start: CHECKING_STATUS,
-            },
-            meta: {
-                displayText: 'DB starting ...',
-                percentComplete: 0,
-            },
-        },
-        [CHECKING_STATUS]: {
-            on: {
-                [DB_CHECK_STATUS_UPDATE_PATHS]: {
-                    actions: assign({
-                        pathToDb: ({ event }) => event.pathToDb,
-                        pathToDir: ({ event }) => event.pathToDir,
-                        pathToDbDir: ({ event }) => event.pathToDbDir,
-                    }),
-                },
-                [DB_CHECK_STATUS_EXISTS]: CONNECTING_TO_DB,
-            },
-            invoke: {
-                src: 'checkStatus',
-                input: ({ context, event }) => ({ context, event }),
-            },
-            meta: {
-                displayText: 'Checking DB status',
-                percentComplete: 60,
-            },
-        },
-        [CONNECTING_TO_DB]: {
-            on: {
-                [DB_CREATING_SUCCESS]: {
-                    target: VALIDATING,
-                    actions: assign({
-                        dbId: ({ event }) => event.dbId,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'connectToDb',
-                input: ({ context }) => ({ context }),
-            },
-            meta: {
-                displayText: 'Connecting to local DB',
-                percentComplete: 70,
-            },
-        },
-        [VALIDATING]: {
-            on: {
-                [DB_VALIDATING_SUCCESS]: {
-                    target: MIGRATING,
-                    // guard: ({ context }) => context.hasFiles,
-                },
-                [DB_VALIDATING_WAIT]: {
-                    target: WAITING_FOR_FILES,
-                    // guard: ({ context }) => !context.hasFiles,
-                },
-            },
-            invoke: {
-                src: 'validate',
-                input: ({ context }) => ({ context }),
-            },
-            meta: {
-                displayText: 'Validating DB',
-                percentComplete: 80,
-            },
-        },
-        // Here we're waiting for migration and schema files to be downloaded
-        [WAITING_FOR_FILES]: {
-            on: {
-                [DB_WAITING_FOR_FILES_RECEIVED]: {
-                    target: MIGRATING,
-                    actions: assign({
-                        hasFiles: true,
-                    }),
-                },
-                [DB_MIGRATING_SUCCESS]: 'ready',
-            },
-            entry: ({ context }) => {
-                if (context.hasFiles) {
-                    emit({ type: DB_WAITING_FOR_FILES_RECEIVED });
+class SqliteConnectionManager {
+    constructor(sqliteModule, idleTimeout = 300000) {
+        // Default idle timeout: 5 minutes
+        this.sqliteModule = sqliteModule;
+        this.idleTimeout = idleTimeout;
+        this.databases = {};
+        this.idleTimers = {};
+    }
+    resetIdleTimer(dbName) {
+        if (this.idleTimers[dbName]) {
+            clearTimeout(this.idleTimers[dbName]);
+        }
+        this.idleTimers[dbName] = setTimeout(() => {
+            this.closeConnection(dbName);
+        }, this.idleTimeout);
+    }
+    getConnection(dbName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.databases[dbName]) {
+                this.resetIdleTimer(dbName);
+                return this.databases[dbName];
+            }
+            const db = new this.sqliteModule();
+            yield db.open(dbName);
+            this.databases[dbName] = db;
+            this.resetIdleTimer(dbName);
+            return db;
+        });
+    }
+    execute(dbName_1, sql_1) {
+        return __awaiter(this, arguments, void 0, function* (dbName, sql, params = []) {
+            const db = yield this.getConnection(dbName);
+            const result = db.exec(sql, params);
+            this.resetIdleTimer(dbName);
+            return result;
+        });
+    }
+    closeConnection(dbName) {
+        if (this.databases[dbName]) {
+            this.databases[dbName].close();
+            delete this.databases[dbName];
+            if (this.idleTimers[dbName]) {
+                clearTimeout(this.idleTimers[dbName]);
+                delete this.idleTimers[dbName];
+            }
+        }
+    }
+}
+
+const logger$5 = debug('app:services:internal:helpers');
+/**
+ * Recursively create directories if they don't exist.
+ * @param {string} dirPath - The directory path to create.
+ */
+const createDirectories = (dirPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const dirPathExists = yield fs.promises.exists(dirPath);
+    if (dirPathExists) {
+        return;
+    }
+    const parentDir = path.dirname(dirPath);
+    const parentDirExists = yield fs.promises.exists(parentDir);
+    if (!parentDirExists) {
+        yield createDirectories(parentDir);
+    }
+    yield fs.promises.mkdir(dirPath, { recursive: true });
+});
+let busy = false;
+const downloadFile = (url, localFilePath) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield fetch(url);
+        const fileData = yield response.text().catch((error) => {
+            console.error(`Failed to parse text from ${url}:`, error);
+        });
+        if (!fileData) {
+            console.error(`No file data from ${url}`);
+            return;
+        }
+        const localDirPath = path.dirname(localFilePath);
+        if (busy) {
+            return;
+        }
+        busy = true;
+        yield createDirectories(localDirPath);
+        const filename = path.basename(localFilePath);
+        const regex = /(\d+)[\w_]+\.(sql|json)$/;
+        const match = filename.match(regex);
+        let migrationNumber;
+        if (match && match.length > 1) {
+            migrationNumber = match[1];
+        }
+        if (migrationNumber) {
+            const filesInDir = yield fs.promises.readdir(localDirPath);
+            for (const file of filesInDir) {
+                if (file === filename) {
+                    continue;
                 }
-            },
-        },
-        [MIGRATING]: {
-            on: {
-                [DB_MIGRATING_WAIT]: WAITING_FOR_FILES,
-                [DB_MIGRATING_SUCCESS]: {
-                    target: 'ready',
-                },
-            },
-            invoke: {
-                src: 'migrate',
-                input: ({ context }) => ({ context }),
-            },
-            meta: {
-                displayText: 'Migrating DB',
-                percentComplete: 90,
-            },
-        },
-        ready: {
-            target: 'idle',
-            meta: {
-                displayText: 'Wrapping up the db ...',
-                percentComplete: 100,
-            },
-        },
-    },
+                const innerMatch = file.match(regex);
+                let existingFileMigrationNumber;
+                if (innerMatch && innerMatch.length > 1) {
+                    existingFileMigrationNumber = innerMatch[1];
+                }
+                if (migrationNumber &&
+                    existingFileMigrationNumber &&
+                    existingFileMigrationNumber === migrationNumber) {
+                    yield fs.promises.unlink(path.join(localDirPath, file));
+                }
+            }
+        }
+        // if (filename === '_journal.json') {
+        //   const exists = await fs.promises.exists(localFilePath)
+        //   if (exists) {
+        //     await fs.promises.rm(localFilePath)
+        //   }
+        //   await fs.promises.writeFile(localFilePath, fileData)
+        // }
+        //
+        // if (filename !== '_journal.json') {
+        //   await fs.promises.writeFile(localFilePath, fileData)
+        // }
+        yield fs.promises.writeFile(localFilePath, fileData);
+    }
+    catch (error) {
+        if (JSON.stringify(error).includes('File exists')) {
+            yield fs.promises.readFile(localFilePath, 'utf-8');
+        }
+        logger$5(`[Error] Failed to download file from ${url}:`, error);
+    }
+    busy = false;
+});
+const fetchDirectory = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(url);
+    return response.json();
+});
+const fetchFilesRecursively = (url, localPath, fileList) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        for (const file of fileList) {
+            const fileUrl = `${url}/${file}`;
+            const fileLocalPath = path.join(localPath, file);
+            // logger(`[fetchFilesRecursively] fileUrl: ${fileUrl}`)
+            // logger(`[fetchFilesRecursively] fileLocalPath: ${fileLocalPath}`)
+            yield downloadFile(fileUrl, fileLocalPath);
+        }
+    }
+    catch (error) {
+        console.error(`Failed to fetch files from ${url}:`, error);
+    }
+});
+const confirmFilesExist = (filePaths) => __awaiter(void 0, void 0, void 0, function* () {
+    let everythingDownloaded = false;
+    for (const filePath of filePaths) {
+        const fullPath = path.join(BROWSER_FS_TOP_DIR, filePath);
+        everythingDownloaded = yield fs.promises.exists(fullPath);
+    }
+    if (!everythingDownloaded) {
+        setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield confirmFilesExist(filePaths);
+        }), 500);
+    }
+});
+const syncDbFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ filePaths, files }) {
+    const fileList = yield fetchDirectory(filePaths);
+    yield fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
+    yield confirmFilesExist(fileList);
+    logger$5('[syncDbFiles] Files synced!');
 });
 
-const logger$2 = debug('app:services:internal:machine');
-createBrowserInspector({
-    autoStart: false,
+const logger$4 = 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 { IDLE, VALIDATING_INPUT, SAVING_CONFIG, CONFIGURING_FS, LOADING_DBS, LOADING_SEED_DB, LOADING_APP_DB, LOADING_SDK_DB, } = InternalState;
-// Create the state machine
-const internalMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        prepareDb,
-        validateInput,
-        configureFs,
-        loadSeedDb,
-        saveConfig,
-        loadAppDb,
-        loadSdkDb,
-    },
-}).createMachine({
-    id: MachineIds.INTERNAL,
-    initial: IDLE,
-    context: ({ input }) => {
-        return Object.assign(Object.assign({}, input), { error: undefined, hasFiles: false });
-    },
-    states: {
-        [IDLE]: {
-            on: {
-                reValidate: VALIDATING_INPUT,
-                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,
-                                },
-                            }),
-                        }),
-                    ],
-                },
-            },
-            meta: {
-                displayText: 'Waiting for something to happen ...',
-                percentComplete: 0,
-            },
-        },
-        [VALIDATING_INPUT]: {
-            on: {
-                [INTERNAL_VALIDATING_INPUT_SUCCESS]: {
-                    target: 'preparingDb',
-                    actions: assign({
-                        endpoints: ({ event }) => event.endpoints,
-                        addresses: ({ event }) => event.addresses,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'validateInput',
-                input: ({ context, event }) => ({ context, event }),
-            },
-            meta: {
-                displayText: 'Validating input',
-                percentComplete: 20,
-            },
-            tags: ['loading'],
-        },
-        preparingDb: {
-            on: {
-                prepareDbSuccess: {
-                    target: CONFIGURING_FS,
-                },
-            },
-            invoke: {
-                src: 'prepareDb',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-        [CONFIGURING_FS]: {
-            on: {
-                [INTERNAL_CONFIGURING_FS_SUCCESS]: {
-                    target: LOADING_SEED_DB,
-                    actions: assign({ hasFiles: true }),
-                },
-            },
-            invoke: {
-                src: 'configureFs',
-                input: ({ context, event }) => ({ context, event }),
-            },
-            meta: {
-                displayText: 'Downloading app files',
-                percentComplete: 30,
-            },
-            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]: {
-            on: {
-                [INTERNAL_LOADING_SEED_DB_SUCCESS]: SAVING_CONFIG,
-                // [DB_ON_SNAPSHOT]: {
-                //   actions: emit(({ event: { snapshot } }) => {
-                //     return { type: CHILD_SNAPSHOT, snapshot }
-                //   }),
-                // },
-            },
-            invoke: {
-                src: 'loadSeedDb',
-                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,
-            },
-            invoke: {
-                src: 'saveConfig',
-                input: ({ context, event }) => ({ context, event }),
-            },
-            meta: {
-                displayText: 'Saving configuration',
-                percentComplete: 80,
-            },
-            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!');
-                            },
-                        },
+const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, void 0, function* () {
+    const addresses = yield getAddressesFromDb();
+    const { filesMetadata } = yield queryClient.fetchQuery({
+        queryKey: ['getFilesMetadata', ...addresses],
+        queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
+            return easClient.request(GET_FILES_METADATA, {
+                where: {
+                    attester: {
+                        in: addresses,
                     },
-                },
-                [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!');
+                    schema: {
+                        is: {
+                            id: {
+                                equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
                             },
                         },
                     },
                 },
-            },
-            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!');
-            },
-            meta: {
-                displayText: "Crossing the t's ...",
-                percentComplete: 90,
-            },
-        },
-        error: {
-            on: {
-                retry: {
-                    target: CONFIGURING_FS,
-                    actions: assign({ error: undefined }),
-                },
-            },
-            entry: () => {
-                logger$2('[sdk] [internal/index] Error!');
-            },
-            meta: {
-                displayText: 'Whoops! Something went wrong.',
-                percentComplete: null,
-            },
-            tags: ['error'],
-        },
-    },
-});
-
-const { UNINITIALIZED, INITIALIZING, INITIALIZED, GETTING_SEED_CLASS, GETTING_SCHEMA_FOR_MODEL, ADDING_MODELS_TO_DB, } = GlobalState;
-createBrowserInspector({
-    autoStart: false,
-});
-const globalMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        initialize,
-        addModelsToDb,
-        getSchemaForModel,
-    },
-}).createMachine({
-    id: MachineIds.GLOBAL,
-    initial: UNINITIALIZED,
-    context: ({ input }) => input,
-    states: {
-        [UNINITIALIZED]: {
-            on: {
-                init: {
-                    target: INITIALIZING,
-                    guard: ({ context }) => {
-                        return typeof window !== 'undefined';
-                    },
-                    actions: [
-                        assign({
-                            isInitialized: false,
-                            addedModelRecordsToDb: false,
-                            models: ({ event }) => event.models,
-                            endpoints: ({ event }) => event.endpoints,
-                            internalService: ({ spawn, context }) => {
-                                return spawn(internalMachine, {
-                                    systemId: MachineIds.INTERNAL,
-                                    input: {
-                                        endpoints: context.endpoints,
-                                    },
-                                });
-                            },
-                            // fileSystemService: ({ spawn, event }) => {
-                            //   return spawn(fileSystemMachine, {
-                            //     systemId: MachineIds.FILE_SYSTEM,
-                            //     input: {
-                            //       addresses: event.addresses,
-                            //     },
-                            //   })
-                            // },
-                        }),
-                        assign(({ event, spawn }) => {
-                            const allItemsServices = {};
-                            for (const [modelName, ModelClass] of Object.entries(event.models)) {
-                                const service = spawn(itemMachineAll, {
-                                    systemId: modelName,
-                                    input: {
-                                        modelName,
-                                        ModelClass,
-                                        modelSchema: ModelClass.schema,
-                                        items: [],
-                                    },
-                                });
-                                allItemsServices[`${modelName}Service`] = service;
-                            }
-                            return allItemsServices;
-                        }),
-                    ],
-                },
-            },
-            meta: {
-                displayText: 'Booting up',
-                percentComplete: 5,
-            },
-            tags: ['loading'],
-        },
-        [INITIALIZING]: {
-            on: {
-                [GLOBAL_INITIALIZING_SEND_CONFIG]: {
-                    actions: assign({
-                        endpoints: ({ event }) => event.endpoints,
-                        environment: ({ event }) => event.environment,
-                        addresses: ({ event }) => event.addresses,
-                        isInitialized: true,
-                    }),
-                },
-                [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,
-            },
-            invoke: {
-                src: 'initialize',
-                input: ({ event, context }) => ({ event, context }),
-                meta: {
-                    displayText: 'Initializing Seed SDK',
-                    percentComplete: 10,
-                },
-                tags: ['loading'],
-            },
-        },
-        [ADDING_MODELS_TO_DB]: {
-            on: {
-                [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {
-                    target: INITIALIZED,
-                    actions: assign({
-                        addedModelRecordsToDb: true,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'addModelsToDb',
-                input: ({ context }) => ({ context }),
-                meta: {
-                    displayText: 'Adding models to database',
-                },
-                tags: ['loading'],
-            },
-        },
-        [INITIALIZED]: {
-            type: 'parallel',
-            on: {
-                getSeedClass: `.${GETTING_SEED_CLASS}`,
-                getSchemaForModel: `.${GETTING_SCHEMA_FOR_MODEL}`,
-            },
-            meta: {
-                displayText: 'Global service ready',
-                percentComplete: 40,
-            },
-            tags: ['loading'],
-            states: {
-                [GETTING_SEED_CLASS]: {
-                    entry: [
-                        (_a) => __awaiter(void 0, [_a], void 0, function* ({ context }) {
-                            let SeedClass;
-                            if (context.environment === 'node') {
-                                const { SeedNode } = yield import('./seed-DM5koJUz.js');
-                                SeedClass = SeedNode;
-                            }
-                            else {
-                                const { SeedBrowser } = yield import('./seed-DHOFK9DF.js');
-                                SeedClass = SeedBrowser;
-                            }
-                            return SeedClass;
-                        }),
-                    ],
-                    meta: {
-                        displayText: 'Getting SeedClass',
-                    },
-                    tags: ['loading'],
-                },
-                [GETTING_SCHEMA_FOR_MODEL]: {
-                    invoke: {
-                        src: 'getSchemaForModel',
-                        input: ({ event, context }) => ({ event, context }),
-                        meta: {
-                            displayText: 'Getting schema for model',
-                        },
-                        tags: ['loading'],
-                    },
-                },
-            },
-        },
-    },
-    // on: {
-    //   '*': {
-    //     actions: emit(({ event }) => {
-    //       return event
-    //     }),
-    //   },
-    // },
-});
-const globalService = createActor(globalMachine, {
-    input: {},
-    // inspect,
-    inspect: (inspEvent) => {
-        eventEmitter.emit('inspect.globalService', inspEvent);
-        // console.log('[sdk] [service/index] inspEvent', inspEvent)
-        // eventEmitter.emit('globalService', inspEvent)
-        // let eventType: string = inspEvent.type
-        // if (inspEvent.event && inspEvent.event.type) {
-        //   eventType = inspEvent.event.type
-        // }
-        //
-        // if (typeof eventType === 'object') {
-        //   eventType = JSON.stringify(eventType)
-        // }
-        //
-        // let srcId = inspEvent.actorRef.id
-        //
-        // if (!srcId.includes('seedSdk')) {
-        //   srcId = inspEvent.actorRef.logic.config.id
-        // }
-        //
-        // if (inspEvent.type === '@xstate.snapshot') {
-        //   if (
-        //     inspEvent.event.type === CHILD_SNAPSHOT &&
-        //     inspEvent.snapshot &&
-        //     inspEvent.snapshot.machine.id === MachineIds.GLOBAL
-        //   ) {
-        //     return
-        //   }
-        //   if (inspEvent.snapshot && inspEvent.snapshot.value) {
-        //     if (typeof window !== 'undefined') {
-        //       eventEmitter.emit('globalService', {
-        //         type: eventType,
-        //         src: srcId,
-        //         snapshot: inspEvent.snapshot,
-        //       })
-        //     }
-        //   }
-        // } else {
-        //   if (typeof window !== 'undefined') {
-        //     let snapshot
-        //
-        //     try {
-        //       snapshot = inspEvent.actorRef.getSnapshot()
-        //     } catch (e) {
-        //       // This fails if the actor hasn't initialized yet, but that's OK I think
-        //       // console.log('[sdk] [service/index] ERROR', e)
-        //     }
-        //
-        //     eventEmitter.emit('globalService', {
-        //       type: eventType,
-        //       src: srcId,
-        //       snapshot,
-        //     })
-        //   }
-        // }
-    },
-});
-globalService.start();
-const getGlobalService = () => globalService;
-
-const logger$1 = debug('app:react:index');
-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;
+    if (!(yield fs.promises.exists('/files'))) {
+        yield fs.promises.mkdir('/files', { recursive: true });
+    }
+    if (!(yield fs.promises.exists('/files/html'))) {
+        yield fs.promises.mkdir('/files/html', { recursive: true });
+    }
+    if (!(yield fs.promises.exists('/files/json'))) {
+        yield fs.promises.mkdir('/files/json', { recursive: true });
+    }
+    if (!(yield fs.promises.exists('/files/images'))) {
+        yield fs.promises.mkdir('/files/images', { recursive: true });
+    }
+    const seedDb = getDb(DB_NAME_SEED);
+    if (!seedDb) {
+        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
+            .select()
+            .from(appState)
+            .where(eq(appState.key, 'excludedTransactions'));
+        let excludedTransactions = new Set();
+        if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
+            const valueString = excludedTransactionsQuery[0].value;
+            if (valueString) {
+                const excludedTransactionsArray = JSON.parse(valueString);
+                excludedTransactions = new Set(excludedTransactionsArray);
+            }
         }
-        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 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;
+        if (excludedTransactions.has(transactionId)) {
+            continue;
         }
-        isReadingDb.current = true;
-        const foundItem = yield Item.find({
-            modelName,
-            seedLocalId,
-            seedUid,
-        });
-        if (!foundItem) {
-            logger$1('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
-            return;
+        const arweave = getArweave();
+        if (!arweave) {
+            console.warn('[fetchAll/actors] [fetchAllBinaryData] arweave not available');
+            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$1('[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);
+        try {
+            const res = yield fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
+            if (res.status !== 200) {
+                logger$4(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                excludedTransactions.add(transactionId);
+                yield writeAppState(seedDb, 'excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
+                continue;
+            }
+            const dataString = yield arweave.transactions
+                .getData(transactionId, {
+                decode: true,
+                string: true,
+            })
+                .catch((error) => {
+                console.error(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`, error);
             });
-            _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 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$1('[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;
+            if (!dataString) {
+                logger$4(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
-            const currentState = internalService.getSnapshot().value;
-            if (currentState === 'ready') {
-                update();
-                return;
+            let contentType = identifyString(dataString);
+            if (contentType !== 'json' &&
+                contentType !== 'base64' &&
+                contentType !== 'html') {
+                const possibleImageType = getImageDataType(dataString);
+                if (!possibleImageType) {
+                    logger$4(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    continue;
+                }
+                contentType = possibleImageType;
             }
-            internalSubscription = internalService.subscribe((snapshot) => {
-                if (snapshot.value === 'ready') {
-                    update();
-                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+            if (contentType === 'url') {
+                const url = dataString;
+                const response = yield fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch image: ${response.statusText}`);
                 }
-            });
-        });
-        _waitForDbs();
-        return () => {
-            if (globalSubscription) {
-                globalSubscription.unsubscribe();
+                // Get the image as a Blob
+                const blob = yield response.blob();
+                const buffer = yield blob.arrayBuffer();
+                const bufferUint8Array = new Uint8Array(buffer);
+                // Extract the file extension from the URL
+                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
+                if (!extensionMatch) {
+                    throw new Error('Unable to determine the file extension from the URL.');
+                }
+                const fileExtension = extensionMatch[0]; // e.g., ".jpg"
+                // Set the file name (you can customize this)
+                // const fileNameFromUrl = `${transactionId}${fileExtension}`
+                yield fs.promises.writeFile(`/files/images/${transactionId}`, bufferUint8Array, {
+                    encoding: 'binary',
+                });
+                continue;
             }
-            if (internalSubscription) {
-                internalSubscription.unsubscribe();
+            const mimeType = getMimeType(dataString);
+            let fileName = transactionId;
+            if (contentType === 'base64') {
+                if (mimeType) {
+                    fileName += `.${mimeType}`;
+                }
+                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+                const base64Data = dataString.split(',').pop() || '';
+                // Decode the Base64 string to binary
+                const binaryString = atob(base64Data);
+                const length = binaryString.length;
+                const binaryData = new Uint8Array(length);
+                for (let i = 0; i < length; i++) {
+                    binaryData[i] = binaryString.charCodeAt(i);
+                }
+                yield fs.promises.writeFile(`/files/images/${fileName}`, binaryData, {
+                    encoding: 'binary',
+                });
+                // if (dataUint8Array && dataUint8Array instanceof Uint8Array) {
+                //   await fs.promises.writeFile(
+                //     `/files/images/${fileName}`,
+                //     dataUint8Array,
+                //   )
+                // }
+            }
+            if (contentType === 'html') {
+                fileName += '.html';
+                yield fs.promises.writeFile(`/files/html/${fileName}`, dataString);
+            }
+            if (contentType === 'json') {
+                fileName += '.json';
+                yield fs.promises.writeFile(`/files/json/${fileName}`, dataString);
             }
-        };
-    }, []);
-    return {
-        dbsAreReady,
-    };
-};
-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 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;
+        catch (error) {
+            logger$4(error);
         }
-        setPropertyObj((draft) => {
-            draft[propertyName] = propertyValue;
+    }
+});
+
+let isInitialized = false;
+const fsInitHandler = (_) => __awaiter(void 0, void 0, void 0, function* () {
+    if (isInitialized) {
+        eventEmitter.emit('fs.init.response', { success: true });
+        return;
+    }
+    try {
+        const handle = yield navigator.storage.getDirectory();
+        // await configure({ backend: WebAccess, handle })
+        yield configureSingle({
+            backend: WebAccess,
+            handle,
         });
-    }, [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,
-    };
+        isInitialized = true;
+        eventEmitter.emit('fs.init.response', { success: true });
+    }
+    catch (e) {
+        if (!isInitialized) {
+            console.error('[fs.init] error initializing fs', e);
+            eventEmitter.emit('fs.init.response', {
+                success: false,
+                error: e,
+            });
+        }
+        // TODO: We can ignore this for now but should figure out if this is being called excessively
+    }
+});
+let areReady = false;
+const setupFsListeners = () => {
+    eventEmitter.addListener('fs.downloadAll.request', downloadAllFilesRequestHandler);
+    eventEmitter.addListener('fs.downloadAllBinary.request', downloadAllFilesBinaryRequestHandler);
+    eventEmitter.addListener('fs.init', fsInitHandler);
+    areReady = true;
 };
-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);
+const areFsListenersReady = () => {
+    return areReady;
+};
+const isFsInitialized = () => {
+    return isInitialized;
+};
+
+const logger$3 = debug('app:internal:actors');
+let sqliteWasmClient;
+let manager;
+const validateInput = fromCallback(({ sendBack, input: { event } }) => {
+    const { endpoints, addresses } = event;
+    if (typeof window === 'undefined') {
+        throw new Error('validateInput called from non-browser context');
+    }
+    if (!endpoints || !endpoints.filePaths || !endpoints.files) {
+        throw new Error('validateInput called with invalid endpoints');
+    }
+    if (!addresses || !addresses.length) {
+        throw new Error('validateInput called with invalid addresses');
+    }
+    const _validateInput = () => __awaiter(void 0, void 0, void 0, function* () {
+        sendBack({
+            type: INTERNAL_VALIDATING_INPUT_SUCCESS,
+            endpoints,
+            addresses,
+        });
+    });
+    _validateInput().then(() => {
+        return;
+    });
+});
+const prepareDb = fromCallback(({ sendBack, input: { event, context } }) => {
+    const _prepareDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (typeof window === 'undefined') {
             return;
         }
-        if (isCreatingItem) {
-            // TODO: should we setup a queue for this?
-            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
+        sqliteWasmClient = yield getSqlite();
+    });
+    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 (sqliteWasmClient) {
+            clearInterval(interval);
+            manager = new SqliteConnectionManager(sqliteWasmClient);
+            sendBack({ type: 'prepareDbSuccess', manager });
             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) {
+        _prepareDb().then(() => {
             return;
+        });
+    }, 500);
+    return () => {
+        if (interval) {
+            clearInterval(interval);
         }
-        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 useGlobalServiceStatus = () => {
-    const globalService = getGlobalService();
-    const status = useSelector(globalService, (snapshot) => {
-        return snapshot.value;
+});
+const configureFs = fromCallback(({ sendBack, input: { context } }) => {
+    const { endpoints, seedDbService, appDbService, sdkDbService } = context;
+    logger$3('[internal/actors] [configureFs] Configuring FS');
+    const services = [seedDbService, appDbService, sdkDbService];
+    const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
+        logger$3('[internal/actors] [configureFs] calling _configureFs');
+        logger$3('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$3('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        yield waitForEvent({
+            req: {
+                eventLabel: 'fs.downloadAll.request',
+                data: { endpoints },
+            },
+            res: {
+                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$3('[internal/actors] [configureFs] fs configured!');
     });
-    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
-        if (!snapshot) {
-            return;
-        }
-        return snapshot.value;
+    // 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
+    // work, but we have to wait for it to be built. Otherwise things like
+    // drizzleMigrate will fail since they can't see the migration files yet.
+    _configureFs().then(() => {
+        sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS });
+        return;
     });
-    useSelector(globalService, (snapshot) => {
-        return snapshot.context.internalService;
+    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 });
+            },
+        });
     });
-    return {
-        status,
-        internalStatus,
+    _loadSeedDb().then(() => {
+        sendBack({ type: INTERNAL_LOADING_SEED_DB_SUCCESS });
+    });
+    return () => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
     };
-};
+});
+const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
+    if (typeof window === 'undefined') {
+        console.error('seedInitBrowser called from non-browser context');
+        sendBack({
+            type: 'error',
+            error: 'Browser method called from non-browser context',
+        });
+    }
+    const { endpoints, addresses } = context;
+    if (!endpoints) {
+        throw new Error('saveConfig called with invalid endpoints');
+    }
+    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 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
+                .insert(appState)
+                .values({
+                key: 'endpoints',
+                value: endpointsValueString,
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
+                    value: endpointsValueString,
+                },
+                setWhere: sql `key = 'endpoints'`,
+            });
+            // logger('[sdk] [internal/actors] Saving addresses to db')
+            yield seedDb
+                .insert(appState)
+                .values({
+                key: 'addresses',
+                value: addressesValueString,
+            })
+                .onConflictDoUpdate({
+                target: appState.key,
+                set: {
+                    value: addressesValueString,
+                },
+                setWhere: sql `key = 'addresses'`,
+            });
+            logger$3('[sdk] [internal/actors] Should be done saving');
+        }
+        catch (error) {
+            console.error('Error saving config:', error);
+        }
+    });
+    _saveConfig().then(() => {
+        logger$3('[sdk] [internal/actors] Successfully saved config');
+        return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
+    });
+    return () => { };
+});
+const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
+    const { appDbService } = context;
+    let subscription;
+    const _loadAppDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            if (appDbService.getSnapshot().value === 'ready') {
+                return resolve();
+            }
+            subscription = appDbService.subscribe({
+                next: (snapshot) => {
+                    if (snapshot.value === 'ready') {
+                        return resolve();
+                    }
+                    sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot });
+                },
+            });
+        });
+    });
+    _loadAppDb().then(() => {
+        sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
+        logger$3('[sdk] [internal/actors] Successfully loaded app DB');
+    });
+    return () => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    };
+});
+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');
+    });
+    return () => {
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+    };
+});
+
+const logger$2 = debug('app:services:db:machine');
+const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
+const dbMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        checkStatus,
+        validate,
+        connectToDb,
+        migrate,
+    },
+}).createMachine({
+    id: MachineIds.DB,
+    initial: CHECKING_STATUS,
+    context: ({ input }) => input,
+    on: {
+        [DB_WAITING_FOR_FILES_RECEIVED]: {
+            actions: assign({
+                hasFiles: ({ event }) => {
+                    logger$2('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    return true;
+                },
+            }),
+        },
+        updateHasFiles: {
+            target: `.${CHECKING_STATUS}`,
+            actions: assign({
+                hasFiles: ({ context, event }) => {
+                    logger$2('[db/machine] updateHasFiles event:', event);
+                    logger$2('[db/machine] updateHasFiles context:', context);
+                    return event.hasFiles;
+                },
+            }),
+        },
+    },
+    // always: {
+    //   target: `.${CHECKING_STATUS}`,
+    //   guard: ({ context, event }) => context.hasFiles && event.type === 'updateHasFiles',
+    // },
+    states: {
+        idle: {
+            on: {
+                start: CHECKING_STATUS,
+            },
+            meta: {
+                displayText: 'DB starting ...',
+                percentComplete: 0,
+            },
+        },
+        [CHECKING_STATUS]: {
+            on: {
+                [DB_CHECK_STATUS_UPDATE_PATHS]: {
+                    actions: assign({
+                        pathToDb: ({ event }) => event.pathToDb,
+                        pathToDir: ({ event }) => event.pathToDir,
+                        pathToDbDir: ({ event }) => event.pathToDbDir,
+                    }),
+                },
+                [DB_CHECK_STATUS_EXISTS]: CONNECTING_TO_DB,
+            },
+            invoke: {
+                src: 'checkStatus',
+                input: ({ context, event }) => ({ context, event }),
+            },
+            meta: {
+                displayText: 'Checking DB status',
+                percentComplete: 60,
+            },
+        },
+        [CONNECTING_TO_DB]: {
+            on: {
+                [DB_CREATING_SUCCESS]: {
+                    target: VALIDATING,
+                    actions: assign({
+                        dbId: ({ event }) => event.dbId,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'connectToDb',
+                input: ({ context }) => ({ context }),
+            },
+            meta: {
+                displayText: 'Connecting to local DB',
+                percentComplete: 70,
+            },
+        },
+        [VALIDATING]: {
+            on: {
+                [DB_VALIDATING_SUCCESS]: {
+                    target: MIGRATING,
+                    // guard: ({ context }) => context.hasFiles,
+                },
+                [DB_VALIDATING_WAIT]: {
+                    target: WAITING_FOR_FILES,
+                    // guard: ({ context }) => !context.hasFiles,
+                },
+            },
+            invoke: {
+                src: 'validate',
+                input: ({ context }) => ({ context }),
+            },
+            meta: {
+                displayText: 'Validating DB',
+                percentComplete: 80,
+            },
+        },
+        // Here we're waiting for migration and schema files to be downloaded
+        [WAITING_FOR_FILES]: {
+            on: {
+                [DB_WAITING_FOR_FILES_RECEIVED]: {
+                    target: MIGRATING,
+                    actions: assign({
+                        hasFiles: true,
+                    }),
+                },
+                [DB_MIGRATING_SUCCESS]: 'ready',
+            },
+            entry: ({ context }) => {
+                if (context.hasFiles) {
+                    emit({ type: DB_WAITING_FOR_FILES_RECEIVED });
+                }
+            },
+        },
+        [MIGRATING]: {
+            on: {
+                [DB_MIGRATING_WAIT]: WAITING_FOR_FILES,
+                [DB_MIGRATING_SUCCESS]: {
+                    target: 'ready',
+                },
+            },
+            invoke: {
+                src: 'migrate',
+                input: ({ context }) => ({ context }),
+            },
+            meta: {
+                displayText: 'Migrating DB',
+                percentComplete: 90,
+            },
+        },
+        ready: {
+            target: 'idle',
+            meta: {
+                displayText: 'Wrapping up the db ...',
+                percentComplete: 100,
+            },
+        },
+    },
+});
+
+const logger$1 = 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;
+// Create the state machine
+const internalMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        prepareDb,
+        validateInput,
+        configureFs,
+        loadSeedDb,
+        saveConfig,
+        loadAppDb,
+        loadSdkDb,
+    },
+}).createMachine({
+    id: MachineIds.INTERNAL,
+    initial: IDLE,
+    context: ({ input }) => {
+        return Object.assign(Object.assign({}, input), { error: undefined, hasFiles: false });
+    },
+    states: {
+        [IDLE]: {
+            on: {
+                reValidate: VALIDATING_INPUT,
+                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,
+                                },
+                            }),
+                        }),
+                    ],
+                },
+            },
+            meta: {
+                displayText: 'Waiting for something to happen ...',
+                percentComplete: 0,
+            },
+        },
+        [VALIDATING_INPUT]: {
+            on: {
+                [INTERNAL_VALIDATING_INPUT_SUCCESS]: {
+                    target: 'preparingDb',
+                    actions: assign({
+                        endpoints: ({ event }) => event.endpoints,
+                        addresses: ({ event }) => event.addresses,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'validateInput',
+                input: ({ context, event }) => ({ context, event }),
+            },
+            meta: {
+                displayText: 'Validating input',
+                percentComplete: 20,
+            },
+            tags: ['loading'],
+        },
+        preparingDb: {
+            on: {
+                prepareDbSuccess: {
+                    target: CONFIGURING_FS,
+                },
+            },
+            invoke: {
+                src: 'prepareDb',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
+        [CONFIGURING_FS]: {
+            on: {
+                [INTERNAL_CONFIGURING_FS_SUCCESS]: {
+                    target: LOADING_SEED_DB,
+                    actions: assign({ hasFiles: true }),
+                },
+            },
+            invoke: {
+                src: 'configureFs',
+                input: ({ context, event }) => ({ context, event }),
+            },
+            meta: {
+                displayText: 'Downloading app files',
+                percentComplete: 30,
+            },
+            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]: {
+            on: {
+                [INTERNAL_LOADING_SEED_DB_SUCCESS]: SAVING_CONFIG,
+                // [DB_ON_SNAPSHOT]: {
+                //   actions: emit(({ event: { snapshot } }) => {
+                //     return { type: CHILD_SNAPSHOT, snapshot }
+                //   }),
+                // },
+            },
+            invoke: {
+                src: 'loadSeedDb',
+                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,
+            },
+            invoke: {
+                src: 'saveConfig',
+                input: ({ context, event }) => ({ context, event }),
+            },
+            meta: {
+                displayText: 'Saving configuration',
+                percentComplete: 80,
+            },
+            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$1('[sdk] [internal/index] App DB loaded!');
+                                    },
+                                },
+                            },
+                            invoke: {
+                                src: 'loadAppDb',
+                                input: ({ context, event }) => ({ context, event }),
+                            },
+                        },
+                        appDbLoaded: {
+                            type: 'final',
+                            entry: () => {
+                                logger$1('[sdk] [internal/index] Entered appDbLoaded!');
+                            },
+                        },
+                    },
+                },
+                [LOADING_SDK_DB]: {
+                    initial: 'loading',
+                    states: {
+                        loading: {
+                            on: {
+                                [INTERNAL_LOADING_SDK_DB_SUCCESS]: {
+                                    target: 'sdkConfigDbLoaded',
+                                    actions: () => {
+                                        logger$1('[sdk] [internal/index] SDK Config DB loaded!');
+                                    },
+                                },
+                            },
+                            invoke: {
+                                src: 'loadSdkDb',
+                                input: ({ context, event }) => ({ context, event }),
+                            },
+                        },
+                        sdkConfigDbLoaded: {
+                            type: 'final',
+                            entry: () => {
+                                logger$1('[sdk] [internal/index] Entered sdkConfigDbLoaded!');
+                            },
+                        },
+                    },
+                },
+            },
+            onDone: {
+                target: 'ready',
+                actions: () => {
+                    logger$1('[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$1('[sdk] [internal/index] Ready!');
+            },
+            meta: {
+                displayText: "Crossing the t's ...",
+                percentComplete: 90,
+            },
+        },
+        error: {
+            on: {
+                retry: {
+                    target: CONFIGURING_FS,
+                    actions: assign({ error: undefined }),
+                },
+            },
+            entry: () => {
+                logger$1('[sdk] [internal/index] Error!');
+            },
+            meta: {
+                displayText: 'Whoops! Something went wrong.',
+                percentComplete: null,
+            },
+            tags: ['error'],
+        },
+    },
+});
+
+const { UNINITIALIZED, INITIALIZING, INITIALIZED, GETTING_SEED_CLASS, GETTING_SCHEMA_FOR_MODEL, ADDING_MODELS_TO_DB, } = GlobalState;
+createBrowserInspector({
+    autoStart: false,
+});
+const globalMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        initialize,
+        addModelsToDb,
+        getSchemaForModel,
+    },
+}).createMachine({
+    id: MachineIds.GLOBAL,
+    initial: UNINITIALIZED,
+    context: ({ input }) => input,
+    states: {
+        [UNINITIALIZED]: {
+            on: {
+                init: {
+                    target: INITIALIZING,
+                    guard: ({ context }) => {
+                        return typeof window !== 'undefined';
+                    },
+                    actions: [
+                        assign({
+                            isInitialized: false,
+                            addedModelRecordsToDb: false,
+                            models: ({ event }) => event.models,
+                            endpoints: ({ event }) => event.endpoints,
+                            internalService: ({ spawn, context }) => {
+                                return spawn(internalMachine, {
+                                    systemId: MachineIds.INTERNAL,
+                                    input: {
+                                        endpoints: context.endpoints,
+                                    },
+                                });
+                            },
+                            // fileSystemService: ({ spawn, event }) => {
+                            //   return spawn(fileSystemMachine, {
+                            //     systemId: MachineIds.FILE_SYSTEM,
+                            //     input: {
+                            //       addresses: event.addresses,
+                            //     },
+                            //   })
+                            // },
+                        }),
+                        assign(({ event, spawn }) => {
+                            const allItemsServices = {};
+                            for (const [modelName, ModelClass] of Object.entries(event.models)) {
+                                const service = spawn(itemMachineAll, {
+                                    systemId: modelName,
+                                    input: {
+                                        modelName,
+                                        ModelClass,
+                                        modelSchema: ModelClass.schema,
+                                        items: [],
+                                    },
+                                });
+                                allItemsServices[`${modelName}Service`] = service;
+                            }
+                            return allItemsServices;
+                        }),
+                    ],
+                },
+            },
+            meta: {
+                displayText: 'Booting up',
+                percentComplete: 5,
+            },
+            tags: ['loading'],
+        },
+        [INITIALIZING]: {
+            on: {
+                [GLOBAL_INITIALIZING_SEND_CONFIG]: {
+                    actions: assign({
+                        endpoints: ({ event }) => event.endpoints,
+                        environment: ({ event }) => event.environment,
+                        addresses: ({ event }) => event.addresses,
+                        isInitialized: true,
+                    }),
+                },
+                [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,
+            },
+            invoke: {
+                src: 'initialize',
+                input: ({ event, context }) => ({ event, context }),
+                meta: {
+                    displayText: 'Initializing Seed SDK',
+                    percentComplete: 10,
+                },
+                tags: ['loading'],
+            },
+        },
+        [ADDING_MODELS_TO_DB]: {
+            on: {
+                [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {
+                    target: INITIALIZED,
+                    actions: assign({
+                        addedModelRecordsToDb: true,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'addModelsToDb',
+                input: ({ context }) => ({ context }),
+                meta: {
+                    displayText: 'Adding models to database',
+                },
+                tags: ['loading'],
+            },
+        },
+        [INITIALIZED]: {
+            type: 'parallel',
+            on: {
+                getSeedClass: `.${GETTING_SEED_CLASS}`,
+                getSchemaForModel: `.${GETTING_SCHEMA_FOR_MODEL}`,
+            },
+            meta: {
+                displayText: 'Global service ready',
+                percentComplete: 40,
+            },
+            tags: ['loading'],
+            states: {
+                [GETTING_SEED_CLASS]: {
+                    entry: [
+                        (_a) => __awaiter(void 0, [_a], void 0, function* ({ context }) {
+                            let SeedClass;
+                            if (context.environment === 'node') {
+                                const { SeedNode } = yield import('./seed-BJtzMyfP.js');
+                                SeedClass = SeedNode;
+                            }
+                            else {
+                                const { SeedBrowser } = yield import('./seed-Ch6JPrtQ.js');
+                                SeedClass = SeedBrowser;
+                            }
+                            return SeedClass;
+                        }),
+                    ],
+                    meta: {
+                        displayText: 'Getting SeedClass',
+                    },
+                    tags: ['loading'],
+                },
+                [GETTING_SCHEMA_FOR_MODEL]: {
+                    invoke: {
+                        src: 'getSchemaForModel',
+                        input: ({ event, context }) => ({ event, context }),
+                        meta: {
+                            displayText: 'Getting schema for model',
+                        },
+                        tags: ['loading'],
+                    },
+                },
+            },
+        },
+    },
+    // on: {
+    //   '*': {
+    //     actions: emit(({ event }) => {
+    //       return event
+    //     }),
+    //   },
+    // },
+});
+const globalService = createActor(globalMachine, {
+    input: {},
+    // inspect,
+    inspect: (inspEvent) => {
+        eventEmitter.emit('inspect.globalService', inspEvent);
+        // console.log('[sdk] [service/index] inspEvent', inspEvent)
+        // eventEmitter.emit('globalService', inspEvent)
+        // let eventType: string = inspEvent.type
+        // if (inspEvent.event && inspEvent.event.type) {
+        //   eventType = inspEvent.event.type
+        // }
+        //
+        // if (typeof eventType === 'object') {
+        //   eventType = JSON.stringify(eventType)
+        // }
+        //
+        // let srcId = inspEvent.actorRef.id
+        //
+        // if (!srcId.includes('seedSdk')) {
+        //   srcId = inspEvent.actorRef.logic.config.id
+        // }
+        //
+        // if (inspEvent.type === '@xstate.snapshot') {
+        //   if (
+        //     inspEvent.event.type === CHILD_SNAPSHOT &&
+        //     inspEvent.snapshot &&
+        //     inspEvent.snapshot.machine.id === MachineIds.GLOBAL
+        //   ) {
+        //     return
+        //   }
+        //   if (inspEvent.snapshot && inspEvent.snapshot.value) {
+        //     if (typeof window !== 'undefined') {
+        //       eventEmitter.emit('globalService', {
+        //         type: eventType,
+        //         src: srcId,
+        //         snapshot: inspEvent.snapshot,
+        //       })
+        //     }
+        //   }
+        // } else {
+        //   if (typeof window !== 'undefined') {
+        //     let snapshot
+        //
+        //     try {
+        //       snapshot = inspEvent.actorRef.getSnapshot()
+        //     } catch (e) {
+        //       // This fails if the actor hasn't initialized yet, but that's OK I think
+        //       // console.log('[sdk] [service/index] ERROR', e)
+        //     }
+        //
+        //     eventEmitter.emit('globalService', {
+        //       type: eventType,
+        //       src: srcId,
+        //       snapshot,
+        //     })
+        //   }
+        // }
+    },
+});
+globalService.start();
+const getGlobalService = () => globalService;
 
 const logger = debug('app:services:events');
 const handleServiceSaveState = (event) => {
@@ -6527,5 +6637,5 @@ 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, getGlobalService as a0, getCorrectId as a1, 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-DbpQM9qG.js.map
+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-DY-qRoqO.js.map