@seedprotocol/sdk 0.1.54 → 0.1.56

package/dist/{index-DQKd-s2Q.js → index-Cdz3ZpGp.js}

@@ -3,7 +3,7 @@ import path, { basename } from 'path';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, assign, createActor, waitFor, setup, emit, raise } from 'xstate';
-import { sql, relations, and, eq, max, or, inArray, like, count, isNotNull, isNull, getTableColumns, gt } from 'drizzle-orm';
+import { sql, relations, and, eq, max, or, count, isNotNull, isNull, inArray, like, getTableColumns, gt } from 'drizzle-orm';
 import { fs, configureSingle } from '@zenfs/core';
 import 'dayjs';
 import { customAlphabet } from 'nanoid';
@@ -16,6 +16,7 @@ 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 { useState, useEffect, useRef, useCallback } from 'react';
 import { BehaviorSubject } from 'rxjs';
 import { immerable, produce, enableMapSet } from 'immer';
 import pluralize from 'pluralize';
@@ -23,7 +24,6 @@ import { createBrowserInspector } from '@statelyai/inspect';
 import { drizzle } from 'drizzle-orm/sqlite-proxy';
 import { WebAccess } from '@zenfs/dom';
 import Arweave from 'arweave';
-import { useState, useEffect, useRef, useCallback } from 'react';
 import { useImmer } from 'use-immer';
 import { useSelector } from '@xstate/react';
 
@@ -239,7 +239,7 @@ const identifyString = (str) => {
     return 'text';
 };
 const getMimeType = (base64) => {
-    if (!base64 || !Object.hasOwn(base64, 'match')) {
+    if (!base64) {
         return null;
     }
     const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
@@ -250,20 +250,22 @@ const getMimeType = (base64) => {
         return null; // MIME type could not be determined
     }
 };
-const getImageDataType = (data) => {
+const getDataTypeFromString = (data) => {
+    const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
+    if (nonImageBase64Regex.test(data)) {
+        return 'base64';
+    }
     // Regular expression for base64 (simple version, checking for base64 format)
-    const base64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+    const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+    if (imageBase64Regex.test(data)) {
+        return 'imageBase64';
+    }
     // Regular expression for URL (simple version, checking for common URL format)
     const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
-    if (base64Regex.test(data)) {
-        return 'base64';
-    }
-    else if (urlRegex.test(data)) {
+    if (urlRegex.test(data)) {
         return 'url';
     }
-    else {
-        return null;
-    }
+    return null;
 };
 const convertTxIdToImageSrc = (txId) => __awaiter(void 0, void 0, void 0, function* () {
     const imageFilePath = `/files/images/${txId}`;
@@ -514,6 +516,9 @@ const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
 const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, seedLocalId, schemaUid, } = context;
+    if (seedLocalId === 'AhiILhtcVq') {
+        console.log('[resolveRelatedValue] seedLocalId', seedLocalId);
+    }
     const _resolveRelatedValue = () => __awaiter(void 0, void 0, void 0, function* () {
         if (!propertyValue || !isRelation) {
             return;
@@ -985,7 +990,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             renderValue: refResolvedDisplayValue,
         });
         if (propertyNameFromDb === 'storageTransactionId') {
-            const { Item } = yield import('./index-NmD9sjcJ.js');
+            const { Item } = yield import('./index-DcYDcCt6.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1092,6 +1097,35 @@ const createVersion = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedL
     return newVersionLocalId;
 });
 
+const createMetadata = (metadataValues, propertyRecordSchema) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    metadataValues.localId = generateId();
+    if (propertyRecordSchema &&
+        propertyRecordSchema.localStorageDir &&
+        propertyRecordSchema.storageType === 'ItemStorage') {
+        metadataValues.refResolvedValue = `${metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`;
+        metadataValues.refValueType = 'file';
+    }
+    return appDb
+        .insert(metadata)
+        .values(Object.assign(Object.assign({}, metadataValues), { createdAt: Date.now(), updatedAt: Date.now() }))
+        .returning();
+});
+
+const modelStore = new Map();
+const getModels = () => {
+    return Object.fromEntries(modelStore);
+};
+const getModel = (modelName) => {
+    return modelStore.get(modelName);
+};
+const getModelNames = () => {
+    return Array.from(modelStore.keys());
+};
+const setModel = (modelName, model) => {
+    modelStore.set(modelName, model);
+};
+
 const logger$l = debug('app:write');
 const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
     if (!modelName || (!seedLocalId && !seedUid)) {
@@ -1111,19 +1145,36 @@ const createSeed = (_a) => __awaiter(void 0, [_a], void 0, function* ({ type, se
     return newSeedLocalId;
 });
 const createNewItem = (_a) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
     var { modelName } = _a, propertyData = __rest(_a, ["modelName"]);
     if (!modelName) {
         throw new Error('A model name is required for createNewItem');
     }
-    const appDb = getAppDb();
+    getAppDb();
     const seedType = modelName.toLowerCase();
     const newSeedId = yield createSeed({ type: seedType });
     const newVersionId = yield createVersion({ seedLocalId: newSeedId });
+    const propertySchemas = (_b = getModel(modelName)) === null || _b === void 0 ? void 0 : _b.schema;
     for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
-        yield appDb.run(sql.raw(`INSERT INTO metadata (seed_local_id, version_local_id, property_name, property_value, model_type, created_at,
-                               attestation_created_at)
-         VALUES ('${newSeedId}', '${newVersionId}', '${propertyName}', '${propertyValue}', '${seedType}', ${Date.now()},
-                 ${Date.now()});`));
+        let propertyRecordSchema;
+        if (propertySchemas && propertySchemas[propertyName]) {
+            propertyRecordSchema = propertySchemas[propertyName];
+        }
+        yield createMetadata({
+            seedLocalId: newSeedId,
+            versionLocalId: newVersionId,
+            propertyName,
+            propertyValue,
+            modelName,
+        }, propertyRecordSchema);
+        // await appDb.run(
+        //   sql.raw(
+        //     `INSERT INTO metadata (seed_local_id, version_local_id, property_name, property_value, model_type, created_at,
+        //                            attestation_created_at)
+        //      VALUES ('${newSeedId}', '${newVersionId}', '${propertyName}', '${propertyValue}', '${seedType}', ${Date.now()},
+        //              ${Date.now()});`,
+        //   ),
+        // )
     }
     // eventEmitter.emit(`item.requestAll`, { modelName })
     return {
@@ -1417,20 +1468,256 @@ const updateMachineContext = {
     }),
 };
 
-const modelStore = new Map();
-const getModels = () => {
-    return Object.fromEntries(modelStore);
-};
-const getModel = (modelName) => {
-    return modelStore.get(modelName);
-};
-const getModelNames = () => {
-    return Array.from(modelStore.keys());
-};
-const setModel = (modelName, model) => {
-    modelStore.set(modelName, model);
+const readFileAsArrayBuffer = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = (e) => __awaiter(void 0, void 0, void 0, function* () {
+            const arrayBuffer = e.target.result;
+            resolve(arrayBuffer);
+        });
+        reader.readAsArrayBuffer(file);
+    });
+});
+const fetchImage = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(url);
+    const mimeType = response.headers.get('Content-Type');
+    const imageBuffer = yield response.arrayBuffer();
+    const bytes = new Uint8Array(imageBuffer);
+    const binaryString = bytes.reduce((acc, byte) => acc + String.fromCharCode(byte), '');
+    let base64 = btoa(binaryString);
+    if (mimeType) {
+        base64 = `data:${mimeType};base64,${base64}`;
+    }
+    return base64;
+});
+const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, schemaUid, } = context;
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
+    if (existingValue === newValue) {
+        sendBack({ type: 'saveValueToDbSuccess' });
+        return;
+    }
+    const _saveImageSrc = () => __awaiter(void 0, void 0, void 0, function* () {
+        let propertyName = propertyNameRaw;
+        if (!propertyNameRaw.endsWith('Id')) {
+            propertyName = `${propertyName}Id`;
+        }
+        let newValueType;
+        let fileData;
+        let mimeType;
+        let fileName;
+        if (typeof newValue === 'string') {
+            newValueType = getDataTypeFromString(newValue);
+        }
+        if (newValueType === 'imageBase64') {
+            mimeType = getMimeType(newValue);
+            fileData = newValue;
+        }
+        if (newValueType === 'url') {
+            fileData = yield fetchImage(newValue);
+        }
+        if (newValue instanceof File) {
+            fileName = newValue.name;
+            mimeType = newValue.type;
+            fileData = yield readFileAsArrayBuffer(newValue);
+        }
+        if (!fileData) {
+            throw new Error('No file data found');
+        }
+        const newImageSeedLocalId = yield createSeed({
+            type: 'image',
+        });
+        if (!fileName) {
+            fileName = newImageSeedLocalId;
+            if (mimeType) {
+                fileName += `.${mimeType.split('/')[1]}`;
+            }
+        }
+        const filePath = `/files/images/${fileName}`;
+        const imageVersionLocalId = yield createVersion({
+            seedLocalId: newImageSeedLocalId,
+            seedType: 'image',
+        });
+        if (fileData instanceof ArrayBuffer) {
+            yield fs.promises.writeFile(filePath, new Uint8Array(fileData));
+        }
+        if (typeof fileData === 'string') {
+            yield fs.promises.writeFile(filePath, fileData);
+        }
+        const refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
+        if (!localId) {
+            yield createMetadata({
+                propertyName,
+                propertyValue: newImageSeedLocalId,
+                seedLocalId,
+                seedUid,
+                versionLocalId: imageVersionLocalId,
+                versionUid,
+                modelName: itemModelName,
+                schemaUid,
+                refSeedType: 'image',
+                refResolvedDisplayValue,
+                refResolvedValue: fileName,
+            }, propertyRecordSchema);
+        }
+        if (localId) {
+            yield updateItemPropertyValue({
+                propertyLocalId: localId,
+                propertyName: propertyNameRaw,
+                newValue: newImageSeedLocalId,
+                seedLocalId,
+                versionLocalId,
+                modelName: itemModelName,
+                schemaUid,
+                refSeedType: 'image',
+                refResolvedDisplayValue,
+                refResolvedValue: fileName,
+            });
+        }
+        sendBack({
+            type: 'updateContext',
+            propertyValue: newImageSeedLocalId,
+            refSeedType: 'image',
+            renderValue: refResolvedDisplayValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
+            resolvedValue: fileName,
+        });
+    });
+    _saveImageSrc().then(() => {
+        sendBack({ type: 'saveImageSrcSuccess' });
+    });
+});
+
+const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, versionLocalId, seedUid, seedLocalId, propertyValue: existingValue, propertyRecordSchema, } = context;
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
+    }
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
+    const _saveRelation = () => __awaiter(void 0, void 0, void 0, function* () {
+        let propertyName = propertyNameRaw;
+        if (!propertyName.endsWith('Id')) {
+            propertyName = `${propertyName}Id`;
+        }
+        let newValueType;
+        if (typeof newValue === 'string') {
+            newValueType = getDataTypeFromString(newValue);
+        }
+        if (newValue instanceof File) {
+            newValueType = 'file';
+        }
+        if (propertyRecordSchema.dataType === 'ImageSrc') {
+            sendBack({
+                type: 'saveImageSrc',
+                newValue,
+                newValueType,
+            });
+            return false;
+        }
+        return true;
+        // let fileType
+        //
+        // const dirs = await fs.promises.readdir('/files')
+        //
+        // for (const dir of dirs) {
+        //   const files = await fs.promises.readdir(`/files/${dir}`)
+        //   if (newValue && files.includes(newValue as string)) {
+        //     fileType = dir
+        //     break
+        //   }
+        // }
+        //
+        // if (newValue && fileType === 'images') {
+        //   const filePath = `/files/images/${newValue}`
+        //   refResolvedDisplayValue = await getContentUrlFromPath(filePath)
+        //   refSeedType = 'image'
+        //   newValue = await createSeed({
+        //     type: refSeedType,
+        //   })
+        //   await createVersion({
+        //     seedLocalId,
+        //     seedUid,
+        //     seedType: refSeedType,
+        //   })
+        // }
+        //
+        // await updateItemPropertyValue({
+        //   propertyLocalId: localId,
+        //   propertyName,
+        //   newValue,
+        //   seedLocalId,
+        //   refSeedType,
+        //   refResolvedValue,
+        //   refResolvedDisplayValue,
+        //   versionLocalId,
+        //   modelName: itemModelName,
+        //   schemaUid,
+        // })
+    });
+    _saveRelation().then((isDone) => {
+        if (isDone) {
+            sendBack({ type: 'saveRelationSuccess' });
+        }
+    });
+});
+
+const getVersionData = () => {
+    const appDb = getAppDb();
+    return appDb.$with('versionData').as(appDb
+        .select({
+        seedLocalId: versions.seedLocalId,
+        seedUid: versions.seedUid,
+        latestVersionUid: versions.uid,
+        latestVersionLocalId: versions.localId,
+        versionsCount: count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
+        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+    })
+        .from(versions)
+        .groupBy(versions.seedLocalId));
 };
 
+const getItemsData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, deleted, }) {
+    const appDb = getAppDb();
+    const conditions = [];
+    if (modelName) {
+        conditions.push(eq(seeds.type, modelName.toLowerCase()));
+    }
+    if (deleted) {
+        conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
+    }
+    if (!deleted) {
+        conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
+    }
+    const versionData = getVersionData();
+    let query = appDb
+        .with(versionData)
+        .select({
+        seedLocalId: seeds.localId,
+        seedUid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        modelName: sql `${modelName}`,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        versionsCount: versionData.versionsCount,
+        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
+        createdAt: seeds.createdAt,
+    })
+        .from(seeds)
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+        .where(and(...conditions))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+        .groupBy(seeds.localId);
+    const itemsData = (yield query);
+    return itemsData;
+});
+
 var _a$2;
 const logger$k = debug('app:property:class');
 const namesThatEndWithId = [];
@@ -2613,7 +2900,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-OyHsE0Zl.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-BjnTnTUw.js');
         const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
@@ -3585,57 +3872,6 @@ const getArweave = () => {
     });
 };
 
-const getVersionData = () => {
-    const appDb = getAppDb();
-    return appDb.$with('versionData').as(appDb
-        .select({
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-        latestVersionUid: versions.uid,
-        latestVersionLocalId: versions.localId,
-        versionsCount: count(versions.localId).as('versionsCount'),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
-    })
-        .from(versions)
-        .groupBy(versions.seedLocalId));
-};
-
-const getItemsData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, deleted, }) {
-    const appDb = getAppDb();
-    const conditions = [];
-    if (modelName) {
-        conditions.push(eq(seeds.type, modelName.toLowerCase()));
-    }
-    if (deleted) {
-        conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
-    }
-    if (!deleted) {
-        conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
-    }
-    const versionData = getVersionData();
-    let query = appDb
-        .with(versionData)
-        .select({
-        seedLocalId: seeds.localId,
-        seedUid: seeds.uid,
-        schemaUid: seeds.schemaUid,
-        modelName: sql `${modelName}`,
-        attestationCreatedAt: seeds.attestationCreatedAt,
-        versionsCount: versionData.versionsCount,
-        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
-        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
-        createdAt: seeds.createdAt,
-    })
-        .from(seeds)
-        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-        .where(and(...conditions))
-        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
-    const itemsData = (yield query);
-    return itemsData;
-});
-
 const getMetadata = (props) => __awaiter(void 0, void 0, void 0, function* () {
     const appDb = getAppDb();
     let storageTransactionId;
@@ -3804,7 +4040,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             if (contentType !== 'json' &&
                 contentType !== 'base64' &&
                 contentType !== 'html') {
-                const possibleImageType = getImageDataType(dataString);
+                const possibleImageType = getDataTypeFromString(dataString);
                 if (!possibleImageType) {
                     logger$b(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
@@ -4822,1806 +5058,1802 @@ const createPublishAttempt = fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-const logger$5 = debug('app:react:services');
-const finalStrings = ['idle', 'ready', 'done', 'success'];
-const getServiceName = (service) => {
-    let name = 'actor';
-    if (service && service.uniqueKey) {
-        name = service.uniqueKey;
-    }
-    if (service && !service.uniqueKey && service.logic && service.logic.config) {
-        name = getServiceUniqueKey(service);
-    }
-    return name;
-};
-const getServiceValue = (service) => {
-    let value;
-    if (service && service.getSnapshot() && service.getSnapshot().value) {
-        value = service.getSnapshot().value;
-    }
-    if (getServiceName(service) === 'global') {
-        if (value &&
-            typeof value === 'object' &&
-            Object.keys(value).length > 0 &&
-            Object.keys(value)[0] === 'initialized') {
-            value = 'ready';
-        }
-    }
-    if (value && typeof value === 'object') {
-        value = JSON.stringify(value);
-    }
-    return value;
-};
-const getServiceUniqueKey = (service) => {
-    if (!service || !service.logic || !service.logic.config) {
-        return;
-    }
-    const config = service.logic.config;
-    if (!config.id) {
-        return;
-    }
-    let uniqueKey = config.id;
-    if (config.id.includes('@seedSdk/')) {
-        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
-    }
-    let snapshot;
-    try {
-        snapshot = service.getSnapshot();
-    }
-    catch (error) {
-        logger$5('Error:', error);
-        return uniqueKey;
-    }
-    if (snapshot) {
-        const context = snapshot.context;
-        if (context && context.dbName) {
-            uniqueKey = context.dbName;
+const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }) => {
+    const { localId } = context;
+    const _preparePublishRequestData = () => __awaiter(void 0, void 0, void 0, function* () {
+        const item = yield Item.find({ seedLocalId: localId });
+        if (!item) {
+            return false;
         }
-        if (context && context.modelNamePlural) {
-            uniqueKey = context.modelNamePlural;
+        const appDb = getAppDb();
+        const modelsRows = yield appDb
+            .select({
+            modelName: models.name,
+            schemaUid: modelUids.uid,
+        })
+            .from(models)
+            .leftJoin(modelUids, eq(modelUids.modelId, models.id))
+            .where(eq(models.name, 'Version'));
+        if (!modelsRows || modelsRows.length === 0) {
+            sendBack({ type: 'preparePublishRequestDataError' });
+            return false;
         }
-        if (context && context.modelName) {
-            uniqueKey = pluralize(context.modelName.toLowerCase());
+        const versionSchemaUid = modelsRows[0].schemaUid;
+        yield item.getEditedProperties();
+        yield getModelSchemas();
+        // const dataEncoder = new SchemaEncoder(modelProperty.schemaDefinition,)
+        // const encodedData = dataEncoder.encodeData(data,)
+        //
+        // itemData.listOfAttestations.push({
+        //   schema : modelProperty.schemaUid,
+        //   data   : [
+        //     {
+        //       ...defaultAttestationData,
+        //       data : encodedData,
+        //     },
+        //   ],
+        // },)
+        const publishRequestData = {
+            seedIsRevocable: false,
+            seedSchemaUid: item.schemaUid,
+            seedUid: item.seedUid,
+            versionSchemaUid,
+            versionUid: item.latestVersionUid,
+            listOfAttestations: [],
+        };
+        sendBack(Object.assign({ type: 'updateContext' }, publishRequestData));
+        return true;
+    });
+    _preparePublishRequestData().then((success) => {
+        if (success) {
+            sendBack({ type: 'preparePublishRequestDataSuccess' });
         }
-    }
-    return uniqueKey;
-};
-const useIsDbReady = () => {
-    const [isDbReady, setIsDbReady] = useState(false);
-    const { internalStatus } = useGlobalServiceStatus();
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            setIsDbReady(true);
+    });
+});
+
+const logger$5 = debug('app:services:publish:actors:upload');
+const upload = fromCallback(({ sendBack, input: { context } }) => {
+    const { localId } = context;
+    const _upload = () => __awaiter(void 0, void 0, void 0, function* () {
+        const item = yield Item.find({ seedLocalId: localId });
+        if (!item) {
+            logger$5('no item with localId', localId);
+            return false;
         }
-    }, [internalStatus]);
-    return isDbReady;
-};
-const useServices = () => {
-    const [actors, setActors] = useState([]);
-    const [percentComplete, setPercentComplete] = useState(5);
-    const actorsMap = new Map();
-    useEffect(() => {
-        const globalServiceListener = (event) => {
-            if (event && event.type === 'init') {
-                return;
+        const editedProperties = yield item.getEditedProperties();
+        for (const propertyData of editedProperties) {
+            if (propertyData.refSeedType === 'image') ;
+        }
+        const uploadItems = [];
+        for (const editedPropertyData of editedProperties) {
+            const propertyName = editedPropertyData.propertyName;
+            const editedProperty = item.properties[propertyName];
+            if (!editedProperty || !editedProperty.propertyDef) {
+                continue;
             }
-            if (event.actorRef &&
-                event.actorRef.logic &&
-                event.actorRef.logic.config) {
-                const service = event.actorRef;
-                const services = [service];
-                if (service.logic.config.id === MachineIds.GLOBAL) {
-                    const context = service.getSnapshot().context;
-                    const keys = Object.keys(context);
-                    for (const key of keys) {
-                        if (!key.startsWith('internal') && key.endsWith('Service')) {
-                            const allItemsService = context[key];
-                            services.push(allItemsService);
-                        }
-                    }
-                }
-                services.forEach((innerService) => {
-                    const uniqueKey = getServiceUniqueKey(innerService);
-                    if (!uniqueKey) {
-                        return;
-                    }
-                    innerService.uniqueKey = uniqueKey;
-                    actorsMap.set(uniqueKey, innerService);
-                });
-                let actorsArray = Array.from(actorsMap.values());
-                actorsArray = orderBy(actorsArray, (a) => a.logic.config.id, ['asc']);
-                setActors(produce(actors, (draft) => {
-                    return actorsArray;
-                }));
+            if (editedProperty.propertyDef.refValueType &&
+                editedProperty.propertyDef.refValueType === 'ImageSrc') {
+                const context = editedProperty.getService().getSnapshot().context;
+                const imageSeedId = context.propertyValue;
+                getCorrectId(imageSeedId);
             }
-        };
-        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 (editedProperty.propertyDef.storageType === 'ItemStorage' &&
+                editedProperty.propertyDef.localStorageDir) ;
         }
-        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);
+        if (uploadItems.length === 0) {
+            return true;
         }
-    }, [actors]);
-    return {
-        services: actors,
-        percentComplete,
-    };
-};
-const useGlobalServiceStatus = () => {
-    const globalService = getGlobalService();
-    const status = useSelector(globalService, (snapshot) => {
-        return snapshot.value;
+        // const turbo = TurboFactory.unauthenticated()
+        // turbo.uploadSignedDataItem()
+        //
+        // const { id, owner, dataCaches, fastFinalityIndexes } = await turbo.uploadFile(() => {
+        //   fileStreamFactory => () => fs.createReadStream(filePath),
+        //   fileSizeFactory => () => fileSize,
+        // });
+        return false;
     });
-    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
-        if (!snapshot) {
-            return;
+    _upload().then((isValid) => {
+        if (isValid) {
+            sendBack({ type: 'uploadSuccess' });
         }
-        return snapshot.value;
-    });
-    useSelector(globalService, (snapshot) => {
-        return snapshot.context.internalService;
     });
-    return {
-        status,
-        internalStatus,
-    };
-};
+});
 
-const logger$4 = debug('app:react:item');
-const useItem = ({ modelName, seedLocalId, seedUid }) => {
-    const [itemData, setItemData] = useImmer({});
-    const [item, setItem] = useState();
-    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) => {
-        setItemData((draft) => {
-            Object.keys(newItem.properties).forEach((propertyName) => {
-                const value = newItem[propertyName];
-                draft[propertyName] = value;
-            });
-        });
-    }, []);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (isReadingDb.current ||
-            internalStatus !== 'ready' ||
-            (!seedUid && !seedLocalId)) {
-            return;
-        }
-        isReadingDb.current = true;
-        const foundItem = yield Item.find({
-            modelName,
-            seedLocalId,
-            seedUid,
-        });
-        if (!foundItem) {
-            logger$4('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
-            return;
-        }
-        setItem(foundItem);
-        updateItem(foundItem);
-        isReadingDb.current = false;
-    }), [internalStatus]);
-    const listenerRef = useRef(readFromDb);
-    useEffect(() => {
-        listenerRef.current = readFromDb;
-    }, [readFromDb]);
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            listenerRef.current();
-        }
-    }, [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$4('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
-                    return;
-                }
-                updateItem(newItem);
-                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`, () => {
-            listenerRef.current();
-        });
-        return () => {
-            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
-        };
-    }, []);
-    return {
-        item,
-        itemData,
-        itemStatus,
-    };
-};
-const useItems = ({ modelName, deleted }) => {
-    const [items, setItems] = useImmer([]);
-    const [isReadingDb, setIsReadingDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const isDbReady = useIsDbReady();
-    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, deleted);
-        setItems(() => allItems);
-        setIsReadingDb(false);
-    }), [modelName, isReadingDb]);
-    useEffect(() => {
-        if (isDbReady && !isInitialized) {
-            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
-                yield readFromDb({ modelName });
-                setIsInitialized(true);
-            });
-            _fetchItems();
-        }
-    }, [isInitialized, isDbReady]);
-    useEffect(() => {
-        eventEmitter.addListener('item.requestAll', readFromDb);
-        return () => {
-            eventEmitter.removeListener('item.requestAll');
-        };
-    }, []);
-    return {
-        items: orderBy(items, [
-            (item) => item.lastVersionPublishedAt ||
-                item.attestationCreatedAt ||
-                item.createdAt,
-        ], ['desc']).slice(0, 10),
-        isReadingDb,
-        isInitialized,
-    };
-};
-const useItemIsReady = () => {
-    const [itemListenersReady, setItemListenersReady] = useState(false);
-    const itemEventListenersHandler = useCallback((_) => {
-        setItemListenersReady(true);
-    }, []);
-    useEffect(() => {
-        const areReady = getAreItemEventHandlersReady();
-        if (areReady) {
-            itemEventListenersHandler(true);
-        }
-        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
-        return () => {
-            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
-        };
-    }, []);
-    return {
-        isReady: itemListenersReady,
-    };
-};
-const useCreateItem = (modelName) => {
-    const [isCreatingItem, setIsCreatingItem] = useState(false);
-    const { isReady } = useItemIsReady();
-    const createItem = useCallback((itemData) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!isReady) {
-            console.error(`[useCreateItem] [createItem] called before listeners are ready`, itemData);
-            return;
-        }
-        if (isCreatingItem) {
-            // TODO: should we setup a queue for this?
-            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
-            return;
-        }
-        setIsCreatingItem(true);
-        const { seedLocalId } = yield createNewItem(Object.assign({ modelName }, itemData));
-        yield Item.find({ modelName, seedLocalId });
-        eventEmitter.emit('item.requestAll', { modelName });
-        setIsCreatingItem(false);
-    }), [isCreatingItem, isReady]);
-    return {
-        createItem,
-        isCreatingItem,
-    };
-};
+const { VALIDATING_ITEM_DATA, CREATING_PUBLISH_ATTEMPT, PREPARING_PUBLISH_REQUEST_DATA, UPLOADING, PUBLISHING, IDLE, } = PublishMachineStates;
+const publishMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        validateItemData,
+        createPublishAttempt,
+        upload,
+        preparePublishRequestData,
+    },
+}).createMachine({
+    id: 'publish',
+    initial: VALIDATING_ITEM_DATA,
+    context: ({ input }) => input,
+    on: {
+        updateContext: updateMachineContext,
+    },
+    states: {
+        [VALIDATING_ITEM_DATA]: {
+            on: {
+                validateItemDataSuccess: [CREATING_PUBLISH_ATTEMPT],
+            },
+            invoke: {
+                src: 'validateItemData',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        [CREATING_PUBLISH_ATTEMPT]: {
+            on: {
+                createPublishAttemptSuccess: [UPLOADING],
+            },
+            invoke: {
+                src: 'createPublishAttempt',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        [UPLOADING]: {
+            on: {
+                uploadingSuccess: [PREPARING_PUBLISH_REQUEST_DATA],
+            },
+            invoke: {
+                src: 'upload',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        [PREPARING_PUBLISH_REQUEST_DATA]: {
+            on: {
+                preparePublishRequestDataSuccess: [UPLOADING],
+            },
+            invoke: {
+                src: 'preparePublishRequestData',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        [PUBLISHING]: {},
+        [IDLE]: {},
+    },
+});
+
+const { UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
+createBrowserInspector({
+    autoStart: false,
+});
+const globalMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    actors: {
+        initialize: initialize$1,
+        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,
+                                    },
+                                });
+                            },
+                        }),
+                    ],
+                },
+            },
+            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,
+                [GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES]: {
+                    actions: [
+                        assign(({ event, spawn }) => {
+                            const allItemsServices = {};
+                            for (const [modelName, ModelClass] of Object.entries(event.create)) {
+                                const service = spawn(itemMachineAll, {
+                                    systemId: modelName,
+                                    input: {
+                                        modelName,
+                                        ModelClass,
+                                        modelSchema: ModelClass.schema,
+                                        items: [],
+                                    },
+                                });
+                                allItemsServices[`${modelName}Service`] = service;
+                            }
+                            for (const [modelName, snapshot] of Object.entries(event.restore)) {
+                                const service = createActor(itemMachineAll, {
+                                    snapshot,
+                                });
+                                service.start();
+                                allItemsServices[`${modelName}Service`] = service;
+                            }
+                            return allItemsServices;
+                        }),
+                        raise({ type: 'allItemsServicesCreated' }),
+                    ],
+                },
+            },
+            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: {
+                publishItemRequest: `.${PUBLISHING_ITEM}`,
+            },
+            meta: {
+                displayText: 'Global service ready',
+                percentComplete: 40,
+            },
+            tags: ['loading'],
+            states: {
+                [PUBLISHING_ITEM]: {
+                    entry: [
+                        assign({
+                            publishItemService: ({ spawn, event }) => spawn(publishMachine, {
+                                id: 'publishService',
+                                input: {
+                                    modelName: event.modelName,
+                                    localId: event.seedLocalId,
+                                },
+                            }),
+                        }),
+                    ],
+                    meta: {
+                        displayText: 'Publishing item',
+                    },
+                    tags: ['publishing'],
+                },
+            },
+        },
+    },
+    // 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$3 = debug('app:react:property');
-const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
-    const [property, setProperty] = useState();
-    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    // const isDbReady = useMemo(() => useIsDbReady(), [])
-    const { internalStatus } = useGlobalServiceStatus();
-    const value = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => {
-        if (!snapshot || !snapshot.context) {
+const publishItemRequestHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, }) {
+    const globalService = getGlobalService();
+    globalService.subscribe((snapshot) => {
+        if (!snapshot ||
+            !snapshot.context ||
+            !snapshot.context.publishItemService) {
             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 (property && property.value !== value) {
-    //     readFromDb()
-    //   }
-    // }, [property, value])
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (internalStatus !== 'ready' ||
-            isReadingFromDb ||
-            (!seedLocalId && !seedUid)) {
-            return;
-        }
-        setIsReadingFromDb(true);
-        const foundProperty = yield ItemProperty.find({
-            propertyName,
-            seedLocalId,
-            seedUid,
-        });
-        setIsReadingFromDb(false);
-        if (!foundProperty) {
-            logger$3(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
-            return;
-        }
-        if (foundProperty.status === 'waitingForDb') {
-            foundProperty.getService().send({ type: 'waitForDbSuccess' });
-        }
-        setProperty(foundProperty);
-        setIsInitialized(true);
-    }), [internalStatus, isReadingFromDb]);
-    // let count = 0
-    //
-    // const refresh = useCallback(() => {
-    //   count++
-    //   console.log('[useItemPropertyTest] [refresh] property', property)
-    // }, [property])
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            readFromDb();
-        }
-    }, [internalStatus]);
-    // useEffect(() => {
-    //   eventEmitter.addListener(
-    //     `property.${seedUid || seedLocalId}.${propertyName}.update`,
-    //     (event) => {
-    //       refresh()
-    //     },
-    //   )
-    //
-    //   return () => {
-    //     eventEmitter.removeListener(
-    //       `property.${seedUid || seedLocalId}.${propertyName}.update`,
-    //     )
-    //   }
-    // }, [])
-    return {
-        property,
-        isInitialized,
-        isReadingFromDb,
-        value,
-        status,
-    };
-};
-const useItemProperties = (item) => {
-    const [propertyObj, setPropertyObj] = useImmer({});
-    useState(false);
-    const updatePropertyObj = useCallback((event) => {
-        if (!item) {
-            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
-            return;
-        }
-        const { propertyName, propertyValue } = event;
-        if (!propertyName) {
-            return;
-        }
-        setPropertyObj((draft) => {
-            draft[propertyName] = propertyValue;
-        });
-    }, [item]);
-    useEffect(() => {
-        if (!item) {
-            return;
-        }
-        const eventKey = `item.${item.seedLocalId}.property.update`;
-        eventEmitter.addListener(eventKey, updatePropertyObj);
-        return () => {
-            eventEmitter.removeListener(eventKey, updatePropertyObj);
-        };
-    }, [item]);
-    return {
-        properties: propertyObj,
-    };
-};
-
-debug('app:react:db');
-
-const deleteItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid }) {
-    const appDb = getAppDb();
-    yield appDb
-        .update(seeds)
-        .set({
-        _markedForDeletion: 1,
-    })
-        .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)));
+    globalService.send({
+        type: 'publishItemRequest',
+        modelName,
+        seedLocalId,
+    });
 });
 
-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$2 = debug('app:services:events');
-const handleServiceSaveState = (event) => {
-    const { state, serviceId } = event;
-    logger$2(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
-    localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state));
-};
-const setupServicesEventHandlers = () => {
-    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
+let areReady = false;
+const setupAllItemsEventHandlers = () => {
+    // eventEmitter.addListener('item.request', itemRequestHandler)
+    // eventEmitter.addListener('item.requestAll', itemRequestAllHandler)
+    // eventEmitter.addListener(
+    //   'item.propertyValuesForSeedUid.request',
+    //   propertyValuesForSeedUid,
+    // )
+    // eventEmitter.addListener('item.create.request', createItemRequestHandler)
+    // eventEmitter.addListener('item.delete.request', itemDeleteRequestHandler)
+    // eventEmitter.addListener('item.update', itemUpdateHandler)
+    eventEmitter.addListener('syncDbWithEas', syncDbWithEasHandler);
+    eventEmitter.addListener('item.publish.request', publishItemRequestHandler);
+    //
+    // eventEmitter.emit('item.events.setupAllItemsEventHandlers')
+    areReady = true;
 };
-
-const saveServiceHandler = (event) => __awaiter(void 0, void 0, void 0, function* () {
-    const globalService = getGlobalService();
-    if (!globalService || !globalService.getSnapshot().context) {
-        return;
-    }
-    const { modelName } = event;
-    const nameOfService = `${modelName}Service`;
-    const service = globalService.getSnapshot().context[nameOfService];
-    yield writeAppState(`snapshot__${modelName}`, JSON.stringify(service.getPersistedSnapshot()));
-});
-
-const setupServiceHandlers = () => {
-    eventEmitter.addListener('service.save', saveServiceHandler);
+const getAreItemEventHandlersReady = () => {
+    return areReady;
 };
 
-const client = {
-    init: ({ config, addresses }) => {
-        const { endpoints, models } = config;
-        for (const [key, value] of Object.entries(models)) {
-            setModel(key, value);
-        }
-        setupFsListeners();
-        setupAllItemsEventHandlers();
-        setupServicesEventHandlers();
-        setupServiceHandlers();
-        if (areFsListenersReady()) {
-            eventEmitter.emit('fs.init');
-        }
-        if (!areFsListenersReady()) {
-            console.error('fs listeners not ready during init');
-        }
-        globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-OyHsE0Zl.js').then(({ models }) => {
-            for (const [key, value] of Object.entries(models)) {
-                setModel(key, value);
+const waitForEvent = (_a) => __awaiter(void 0, [_a], void 0, function* ({ req, res }) {
+    const eventId = generateId();
+    return new Promise((resolve) => {
+        const internalHandler = (event) => {
+            if (!event) {
+                return;
+            }
+            const { eventId: _eventId } = event;
+            if (_eventId && _eventId === eventId) {
+                eventEmitter.removeListener(res.eventLabel, internalHandler);
+                resolve(event);
             }
-        });
-    },
-    subscribe: (callback) => {
-        callback({
-            type: '@xstate.snapshot',
-            actorRef: globalService,
-            snapshot: globalService.getSnapshot(),
-        });
-        eventEmitter.addListener('globalService', callback);
-        return {
-            unsubscribe: () => {
-                eventEmitter.removeListener('globalService', callback);
-            },
-        };
-    },
-    on: (outerEvent, callback) => {
-        eventEmitter.addListener(outerEvent, callback);
-        return {
-            unsubscribe: () => {
-                eventEmitter.removeListener(outerEvent, callback);
-            },
         };
-    },
-    getSeedClass: () => __awaiter(void 0, void 0, void 0, function* () {
-        return new Promise((resolve) => {
-            const subscription = globalService.subscribe((snapshot) => {
-                if (snapshot.status === 'done') {
-                    resolve(snapshot.output);
-                }
-            });
-            globalService.send({ type: 'getSeed' });
-            subscription.unsubscribe();
-        });
-    }),
-    getModel: (modelName) => {
-        return getModel(modelName);
-    },
-    getModels: () => {
-        return getModels();
-    },
-    getModelNames: () => {
-        return getModelNames();
-    },
-};
+        eventEmitter.addListener(res.eventLabel, internalHandler);
+        eventEmitter.emit(req.eventLabel, Object.assign(Object.assign({}, req.data), { eventId }));
+    });
+});
 
-const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }) => {
-    const { localId } = context;
-    const _preparePublishRequestData = () => __awaiter(void 0, void 0, void 0, function* () {
-        const item = yield Item.find({ seedLocalId: localId });
-        if (!item) {
+const hydrateExistingItem = fromCallback(({ sendBack, input: { event, context } }) => {
+    const { existingItem } = event;
+    const { seedUid, seedLocalId, ModelClass } = context;
+    if (!ModelClass) {
+        throw new Error('ModelClass not found');
+    }
+    const modelName = ModelClass.originalConstructor.name;
+    const _checkForItemOnAllItemsService = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!existingItem.seedLocalId && !existingItem.seedUid) {
+            console.warn('[singleItemActors] [hydrateExistingItem] No seedLocalId or seedUid found on existingItem');
             return false;
         }
-        const appDb = getAppDb();
-        const modelsRows = yield appDb
-            .select({
-            modelName: models.name,
-            schemaUid: modelUids.uid,
-        })
-            .from(models)
-            .leftJoin(modelUids, eq(modelUids.modelId, models.id))
-            .where(eq(models.name, 'Version'));
-        if (!modelsRows || modelsRows.length === 0) {
-            sendBack({ type: 'preparePublishRequestDataError' });
+        if (!seedUid && !seedLocalId) {
             return false;
         }
-        const versionSchemaUid = modelsRows[0].schemaUid;
-        yield item.getEditedProperties();
-        yield getModelSchemas();
-        // const dataEncoder = new SchemaEncoder(modelProperty.schemaDefinition,)
-        // const encodedData = dataEncoder.encodeData(data,)
-        //
-        // itemData.listOfAttestations.push({
-        //   schema : modelProperty.schemaUid,
-        //   data   : [
-        //     {
-        //       ...defaultAttestationData,
-        //       data : encodedData,
-        //     },
-        //   ],
-        // },)
-        const publishRequestData = {
-            seedIsRevocable: false,
-            seedSchemaUid: item.schemaUid,
-            seedUid: item.seedUid,
-            versionSchemaUid,
-            versionUid: item.latestVersionUid,
-            listOfAttestations: [],
-        };
-        sendBack(Object.assign({ type: 'updateContext' }, publishRequestData));
+        yield waitForEvent({
+            req: {
+                eventLabel: 'item.request',
+                data: {
+                    modelName,
+                    seedUid,
+                    seedLocalId,
+                    source: 'hydrateExistingItem',
+                },
+            },
+            res: {
+                eventLabel: `item.${modelName}.${seedLocalId}.response`,
+            },
+        });
         return true;
+        // return new Promise((resolve) => {
+        // const timeStart = Date.now()
+        //
+        // const interval = setInterval(() => {
+        //   const timeElapsed = Date.now() - timeStart
+        //   if (timeElapsed > 2000) {
+        //     eventEmitter.emit('item.request', {
+        //       modelName,
+        //       versionUid,
+        //       versionLocalId,
+        //       source: 'hydrateExistingItem',
+        //     })
+        //   }
+        //   if (timeElapsed > 30000) {
+        //     clearInterval(interval)
+        //     console.error(
+        //       `[singleItemActors] [hydrateExistingItem] ${timeElapsed / 1000}s elapsed for ${modelName} ${versionLocalId}`,
+        //       context,
+        //     )
+        //     eventEmitter.removeListener(
+        //       `item.${modelName}.response`,
+        //       handleItemRequestResponse,
+        //     )
+        //     resolve(false)
+        //   }
+        // }, 500)
+        // const handleItemRequestResponse = (event) => {
+        //   if (
+        //     event.item &&
+        //     ((event.item.versionLocalId &&
+        //       event.item.versionLocalId === versionLocalId) ||
+        //       (event.item.versionUid && event.item.versionUid === versionUid))
+        //   ) {
+        //     clearInterval(interval)
+        //     eventEmitter.removeListener(
+        //       `item.${modelName}.response`,
+        //       handleItemRequestResponse,
+        //     )
+        //     resolve(true)
+        //   }
+        // }
+        //
+        // eventEmitter.addListener(
+        //   `item.${modelName}.response`,
+        //   handleItemRequestResponse,
+        // )
+        //
+        // eventEmitter.emit('item.request', {
+        //   modelName,
+        //   versionUid,
+        //   versionLocalId,
+        //   source: 'hydrateExistingItem',
+        // })
+        // })
+        // if (existingItem.versionLocalId && !existingItem.versionLocalId) {
+        //   console.log(
+        //     `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
+        //   )
+        //
+        //   return true
+        // }
+        //
+        // console.log(
+        //   `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
+        // )
+        // return true
     });
-    _preparePublishRequestData().then((success) => {
-        if (success) {
-            sendBack({ type: 'preparePublishRequestDataSuccess' });
-        }
-    });
-});
-
-const logger$1 = debug('app:services:publish:actors:upload');
-const upload = fromCallback(({ sendBack, input: { context } }) => {
-    const { localId } = context;
-    const _upload = () => __awaiter(void 0, void 0, void 0, function* () {
-        const item = yield Item.find({ seedLocalId: localId });
-        if (!item) {
-            logger$1('no item with localId', localId);
-            return false;
-        }
-        const editedProperties = yield item.getEditedProperties();
-        for (const propertyData of editedProperties) {
-            if (propertyData.refSeedType === 'image') ;
-        }
-        const uploadItems = [];
-        for (const editedPropertyData of editedProperties) {
-            const propertyName = editedPropertyData.propertyName;
-            const editedProperty = item.properties[propertyName];
-            if (!editedProperty || !editedProperty.propertyDef) {
-                continue;
-            }
-            if (editedProperty.propertyDef.refValueType &&
-                editedProperty.propertyDef.refValueType === 'ImageSrc') {
-                const context = editedProperty.getService().getSnapshot().context;
-                const imageSeedId = context.propertyValue;
-                getCorrectId(imageSeedId);
-            }
-            if (editedProperty.propertyDef.storageType === 'ItemStorage' &&
-                editedProperty.propertyDef.localStorageDir) ;
+    _checkForItemOnAllItemsService().then((shouldContinue) => {
+        if (!shouldContinue) {
+            sendBack({ type: 'hydrateExistingItemFailure' });
+            return;
         }
-        if (uploadItems.length === 0) {
-            return true;
+        // for (const [key, value] of Object.entries(existingItem)) {
+        //   sendBack({
+        //     type: 'updateValue',
+        //     propertyName: key,
+        //     propertyValue: value,
+        //     source: 'db',
+        //   })
+        // }
+        sendBack({ type: 'hydrateExistingItemSuccess' });
+    });
+});
+
+const hydrateNewItem = fromCallback(({ sendBack, input: { context } }) => {
+    const { seedUid, versionUid, modelName } = context;
+    let newSeedLocalId;
+    const _hydrateNewItem = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!modelName) {
+            throw new Error('modelName is required');
         }
-        // const turbo = TurboFactory.unauthenticated()
-        // turbo.uploadSignedDataItem()
-        //
-        // const { id, owner, dataCaches, fastFinalityIndexes } = await turbo.uploadFile(() => {
-        //   fileStreamFactory => () => fs.createReadStream(filePath),
-        //   fileSizeFactory => () => fileSize,
-        // });
-        return false;
+        newSeedLocalId = yield createSeed({
+            type: modelName.toLowerCase(),
+            seedUid: seedUid !== null && seedUid !== void 0 ? seedUid : 'NULL',
+        });
+        yield createVersion({
+            seedLocalId: newSeedLocalId,
+            seedType: modelName.toLowerCase(),
+            uid: versionUid !== null && versionUid !== void 0 ? versionUid : 'NULL',
+        });
     });
-    _upload().then((isValid) => {
-        if (isValid) {
-            sendBack({ type: 'uploadSuccess' });
+    _hydrateNewItem().then(() => {
+        sendBack({ type: 'hydrateNewItemSuccess' });
+    });
+});
+
+const fetchDataFromEas = fromCallback(({ sendBack, input: { context } }) => {
+    const { ModelClass, modelTableName, versionUid } = context;
+    const propertiesMetadata = new Map();
+    // EAS is the final source of truth, so we need to see if our Item is
+    // already represented there. Then we need to intelligently sync/merge
+    // with whatever new data has been created on the device before the sync.
+    for (const [propertyName, propertyMetadata] of Object.entries(ModelClass.schema)) {
+        if (propertyMetadata) {
+            propertiesMetadata.set(propertyName, propertyMetadata);
         }
+    }
+    sendBack({ type: 'updatePropertiesMetadata', propertiesMetadata });
+    if (!versionUid) {
+        // In this case this is a local only item, so we don't need to fetch anything
+        return;
+    }
+    const _fetchDataFromEas = () => __awaiter(void 0, void 0, void 0, function* () {
+        // Fetch Properties by versionUid
+        const { itemProperties } = yield queryClient.fetchQuery({
+            queryKey: ['getProperties', versionUid],
+            queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
+                return easClient.request(GET_PROPERTIES, {
+                    where: {
+                        refUID: {
+                            in: [versionUid],
+                        },
+                        decodedDataJson: {
+                            not: {
+                                // The first of many filters to keep bad data out
+                                contains: '"value":"0x0000000000000000000000000000000000000000000000000000000000000020"',
+                            },
+                        },
+                    },
+                });
+            }),
+        });
+        // Filter properties by schemaId
+        const selectedPropertiesMap = {};
+        itemProperties.forEach((property) => {
+            const existingProperties = selectedPropertiesMap[property.schemaId] || [];
+            existingProperties.push(property);
+            selectedPropertiesMap[property.schemaId] = existingProperties;
+        });
+        // For each schemaId, sort property Attestations by timeCreated DESC
+        Object.keys(selectedPropertiesMap).forEach((schemaId) => {
+            const sorted = selectedPropertiesMap[schemaId].sort((a, b) => {
+                return a.timeCreated - b.timeCreated;
+            });
+            selectedPropertiesMap[schemaId] = sorted;
+        });
+        Object.keys(selectedPropertiesMap).forEach((schemaId) => {
+            // TODO: Finish this logic
+            // console.log('[singleItemActors] [fetchDataFromEas] schemaId', schemaId)
+            // sendBack({ type: 'addPropertyAttestation', schemaId })
+        });
+        // Attach processed properties to the itemService/itemMachine context
+        sendBack({
+            type: 'updatedPropertiesBySchemaUid',
+            propertiesBySchemaUid: selectedPropertiesMap,
+        });
+    });
+    _fetchDataFromEas().then(() => {
+        sendBack({ type: 'fetchDataFromEasSuccess' });
     });
 });
 
-const { VALIDATING_ITEM_DATA, CREATING_PUBLISH_ATTEMPT, PREPARING_PUBLISH_REQUEST_DATA, UPLOADING, PUBLISHING, IDLE, } = PublishMachineStates;
-const publishMachine = setup({
+const itemMachineSingle = setup({
     types: {
         context: {},
         input: {},
     },
     actors: {
-        validateItemData,
-        createPublishAttempt,
-        upload,
-        preparePublishRequestData,
+        waitForDb,
+        initialize: initialize$2,
+        hydrateExistingItem,
+        hydrateNewItem,
+        fetchDataFromEas,
     },
 }).createMachine({
-    id: 'publish',
-    initial: VALIDATING_ITEM_DATA,
+    id: MachineIds.ITEM,
+    initial: 'waitingForDb',
     context: ({ input }) => input,
     on: {
-        updateContext: updateMachineContext,
-    },
-    states: {
-        [VALIDATING_ITEM_DATA]: {
-            on: {
-                validateItemDataSuccess: [CREATING_PUBLISH_ATTEMPT],
-            },
-            invoke: {
-                src: 'validateItemData',
-                input: ({ context }) => ({ context }),
-            },
+        updatedPropertiesBySchemaUid: {
+            actions: assign({
+                propertiesBySchemaUid: ({ event }) => event.propertiesBySchemaUid,
+            }),
         },
-        [CREATING_PUBLISH_ATTEMPT]: {
-            on: {
-                createPublishAttemptSuccess: [UPLOADING],
-            },
-            invoke: {
-                src: 'createPublishAttempt',
-                input: ({ context }) => ({ context }),
-            },
+        updatePropertiesMetadata: {
+            actions: assign({
+                propertiesMetadata: ({ event }) => event.propertiesMetadata,
+            }),
         },
-        [UPLOADING]: {
-            on: {
-                uploadingSuccess: [PREPARING_PUBLISH_REQUEST_DATA],
-            },
-            invoke: {
-                src: 'upload',
-                input: ({ context }) => ({ context }),
-            },
+        updateProperties: {
+            actions: assign({
+                propertiesUpdatedAt: Date.now(),
+            }),
         },
-        [PREPARING_PUBLISH_REQUEST_DATA]: {
-            on: {
-                preparePublishRequestDataSuccess: [UPLOADING],
-            },
-            invoke: {
-                src: 'preparePublishRequestData',
-                input: ({ context }) => ({ context }),
-            },
+        updateValue: {
+            actions: assign(({ event, context }) => {
+                let { propertyInstances } = context;
+                if (!propertyInstances) {
+                    propertyInstances = new Map();
+                }
+                const { propertyName, propertyValue } = event;
+                if (!propertyInstances.has(propertyName)) {
+                    return {
+                        [propertyName]: propertyValue,
+                    };
+                }
+                const propertyInstance = propertyInstances.get(propertyName);
+                propertyInstance.value = propertyValue;
+                propertyInstances.set(propertyName, propertyInstance);
+                // TODO: use immer here
+                return {
+                    propertyInstances,
+                };
+            }),
         },
-        [PUBLISHING]: {},
-        [IDLE]: {},
-    },
-});
-
-const { UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
-createBrowserInspector({
-    autoStart: false,
-});
-const globalMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        initialize: initialize$1,
-        addModelsToDb,
-        getSchemaForModel,
+        addPropertyInstance: {
+            actions: assign(({ context, event }) => {
+                const propertyInstances = context.propertyInstances || new Map();
+                propertyInstances.set(event.propertyName, event.propertyInstance);
+                return {
+                    propertyInstances,
+                };
+            }),
+        },
+        // addPropertyAttestation: {
+        //   actions: assign(({ context, event }) => {
+        //     console.log('[singleItemMachine] [addPropertyAttestation] event', event)
+        //     const propertyInstances =
+        //       context.propertyInstances || new Map<string, typeof ItemProperty>()
+        //     propertyInstances.set(event.propertyName, event.propertyInstances)
+        //     return {
+        //       propertyInstances,
+        //     }
+        //   }),
+        // },
     },
-}).createMachine({
-    id: MachineIds.GLOBAL,
-    initial: UNINITIALIZED,
-    context: ({ input }) => input,
     states: {
-        [UNINITIALIZED]: {
+        idle: {},
+        waitingForDb: {
             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,
-                                    },
-                                });
-                            },
-                        }),
-                    ],
-                },
+                waitForDbSuccess: 'initializing',
             },
-            meta: {
-                displayText: 'Booting up',
-                percentComplete: 5,
+            invoke: {
+                src: 'waitForDb',
             },
-            tags: ['loading'],
         },
-        [INITIALIZING]: {
+        initializing: {
             on: {
-                [GLOBAL_INITIALIZING_SEND_CONFIG]: {
+                hasExistingItem: {
+                    target: 'idle',
                     actions: assign({
-                        endpoints: ({ event }) => event.endpoints,
-                        environment: ({ event }) => event.environment,
-                        addresses: ({ event }) => event.addresses,
-                        isInitialized: true,
+                        modelTableName: ({ event }) => event.modelTableName,
+                        modelNamePlural: ({ event }) => event.modelNamePlural,
+                        modelName: ({ event }) => event.modelName,
+                        existingItem: ({ event }) => event.existingItem,
                     }),
                 },
-                [GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY]: ADDING_MODELS_TO_DB,
-                [GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES]: {
-                    actions: [
-                        assign(({ event, spawn }) => {
-                            const allItemsServices = {};
-                            for (const [modelName, ModelClass] of Object.entries(event.create)) {
-                                const service = spawn(itemMachineAll, {
-                                    systemId: modelName,
-                                    input: {
-                                        modelName,
-                                        ModelClass,
-                                        modelSchema: ModelClass.schema,
-                                        items: [],
-                                    },
-                                });
-                                allItemsServices[`${modelName}Service`] = service;
-                            }
-                            for (const [modelName, snapshot] of Object.entries(event.restore)) {
-                                const service = createActor(itemMachineAll, {
-                                    snapshot,
-                                });
-                                service.start();
-                                allItemsServices[`${modelName}Service`] = service;
-                            }
-                            return allItemsServices;
-                        }),
-                        raise({ type: 'allItemsServicesCreated' }),
-                    ],
+                isNewItem: {
+                    target: 'idle',
+                    actions: assign({
+                        modelTableName: ({ event }) => event.modelTableName,
+                        modelNamePlural: ({ event }) => event.modelNamePlural,
+                        modelName: ({ event }) => event.modelName,
+                    }),
                 },
             },
             invoke: {
                 src: 'initialize',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
+        hydratingExistingItem: {
+            on: {
+                hydrateExistingItemSuccess: 'idle',
+                hydrateExistingItemFailure: 'destroying',
+            },
+            invoke: {
+                src: 'hydrateExistingItem',
                 input: ({ event, context }) => ({ event, context }),
-                meta: {
-                    displayText: 'Initializing Seed SDK',
-                    percentComplete: 10,
-                },
-                tags: ['loading'],
             },
         },
-        [ADDING_MODELS_TO_DB]: {
+        hydratingNewItem: {
             on: {
-                [GLOBAL_ADDING_MODELS_TO_DB_SUCCESS]: {
-                    target: INITIALIZED,
-                    actions: assign({
-                        addedModelRecordsToDb: true,
-                    }),
-                },
+                hydrateNewItemSuccess: 'idle',
             },
             invoke: {
-                src: 'addModelsToDb',
+                src: 'hydrateNewItem',
                 input: ({ context }) => ({ context }),
-                meta: {
-                    displayText: 'Adding models to database',
-                },
-                tags: ['loading'],
             },
         },
-        [INITIALIZED]: {
-            type: 'parallel',
+        fetchingRemoteData: {
             on: {
-                publishItemRequest: `.${PUBLISHING_ITEM}`,
-            },
-            meta: {
-                displayText: 'Global service ready',
-                percentComplete: 40,
+                fetchRemoteDataSuccess: 'idle',
             },
-            tags: ['loading'],
-            states: {
-                [PUBLISHING_ITEM]: {
-                    entry: [
-                        assign({
-                            publishItemService: ({ spawn, event }) => spawn(publishMachine, {
-                                id: 'publishService',
-                                input: {
-                                    modelName: event.modelName,
-                                    localId: event.seedLocalId,
-                                },
-                            }),
-                        }),
-                    ],
-                    meta: {
-                        displayText: 'Publishing item',
-                    },
-                    tags: ['publishing'],
-                },
+            invoke: {
+                src: 'fetchRemoteData',
+                input: ({ context }) => ({ context }),
             },
         },
+        // fetchingDataFromEas: {
+        //   on: {
+        //     fetchDataFromEasSuccess: 'savingDataToDb',
+        //   },
+        //   invoke: {
+        //     src: 'fetchDataFromEas',
+        //     input: ({ context }) => ({ context }),
+        //   },
+        // },
+        // savingDataToDb: {
+        //   on: {
+        //     saveDataToDbSuccess: 'idle',
+        //   },
+        //   invoke: {
+        //     src: 'saveDataToDb',
+        //     input: ({ context }) => ({ context }),
+        //   },
+        // },
+        destroying: {
+            type: 'final',
+        },
     },
-    // 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 publishItemRequestHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, }) {
-    const globalService = getGlobalService();
-    globalService.subscribe((snapshot) => {
-        if (!snapshot ||
-            !snapshot.context ||
-            !snapshot.context.publishItemService) {
-            return;
-        }
-    });
-    globalService.send({
-        type: 'publishItemRequest',
-        modelName,
-        seedLocalId,
-    });
 });
 
-let areReady = false;
-const setupAllItemsEventHandlers = () => {
-    // eventEmitter.addListener('item.request', itemRequestHandler)
-    // eventEmitter.addListener('item.requestAll', itemRequestAllHandler)
-    // eventEmitter.addListener(
-    //   'item.propertyValuesForSeedUid.request',
-    //   propertyValuesForSeedUid,
-    // )
-    // eventEmitter.addListener('item.create.request', createItemRequestHandler)
-    // eventEmitter.addListener('item.delete.request', itemDeleteRequestHandler)
-    // eventEmitter.addListener('item.update', itemUpdateHandler)
-    eventEmitter.addListener('syncDbWithEas', syncDbWithEasHandler);
-    eventEmitter.addListener('item.publish.request', publishItemRequestHandler);
-    //
-    // eventEmitter.emit('item.events.setupAllItemsEventHandlers')
-    areReady = true;
-};
-const getAreItemEventHandlersReady = () => {
-    return areReady;
-};
-
-const waitForEvent = (_a) => __awaiter(void 0, [_a], void 0, function* ({ req, res }) {
-    const eventId = generateId();
-    return new Promise((resolve) => {
-        const internalHandler = (event) => {
-            if (!event) {
-                return;
-            }
-            const { eventId: _eventId } = event;
-            if (_eventId && _eventId === eventId) {
-                eventEmitter.removeListener(res.eventLabel, internalHandler);
-                resolve(event);
-            }
-        };
-        eventEmitter.addListener(res.eventLabel, internalHandler);
-        eventEmitter.emit(req.eventLabel, Object.assign(Object.assign({}, req.data), { eventId }));
-    });
+const getItemProperties = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, edited, }) {
+    const appDb = getAppDb();
+    const whereClauses = [isNotNull(metadata.propertyName)];
+    const uidWhereClause = seedUid
+        ? eq(seeds.uid, seedUid)
+        : isNull(seeds.uid);
+    const localWhereClause = seedLocalId
+        ? eq(seeds.localId, seedLocalId)
+        : isNull(seeds.localId);
+    whereClauses.push(or(localWhereClause, uidWhereClause));
+    whereClauses.push(isNotNull(metadata.propertyName));
+    whereClauses.push(isNotNull(metadata.easDataType));
+    if (typeof edited !== 'undefined') {
+        if (edited) {
+            whereClauses.push(isNull(metadata.uid));
+        }
+        if (!edited) {
+            whereClauses.push(isNotNull(metadata.uid));
+        }
+    }
+    // if (!seedLocalId || !seedUid) {
+    //   const seedRows = await appDb
+    //     .select({
+    //       localId: seeds.localId,
+    //       uid: seeds.uid,
+    //     })
+    //     .from(seeds)
+    //     .where(or(localWhereClause, uidWhereClause))
+    //
+    //   if (seedRows && seedRows.length > 0) {
+    //     seedUid = seedRows[0].uid as string
+    //     seedLocalId = seedRows[0].localId as string
+    //   }
+    // }
+    const metadataColumns = getTableColumns(metadata);
+    const propertiesData = yield appDb
+        .select(Object.assign({}, metadataColumns))
+        .from(seeds)
+        .leftJoin(metadata, eq(metadata.seedLocalId, seeds.localId))
+        .leftJoin(versions, eq(versions.localId, seeds.localId))
+        .where(and(...whereClauses))
+        .groupBy(metadata.propertyName);
+    return propertiesData;
 });
+// const localIdWhere = seedLocalId
+//   ? `s.local_id = '${seedLocalId}'`
+//   : 's.local_id IS NULL'
+// const uidWhere = seedUid ? `s.uid = '${seedUid}'` : 's.uid IS NULL'
+//
+// const queryStatement = `WITH LatestMetadata as (SELECT m.property_name,
+//                                                        m.property_value,
+//                                                        m.version_local_id,
+//                                                        MAX(m.attestation_created_at),
+//                                                        m.uid,
+//                                                        m.seed_local_id,
+//                                                        seed_uid
+//                                                 FROM metadata m
+//                                                          JOIN seeds s ON s.local_id = m.seed_local_id
+//                                                 GROUP BY m.property_name),
+//
+//                              LatestVersion as (SELECT v.local_id,
+//                                                       MAX(v.attestation_created_at) as attestation_created_at,
+//                                                       v.uid,
+//                                                       v.seed_local_id,
+//                                                       v.seed_uid
+//                                                FROM versions v
+//                                                         JOIN seeds s ON s.local_id = v.seed_local_id
+//                                                GROUP BY s.local_id)
+//
+//
+//                         SELECT s.local_id,
+//                                s.uid,
+//                                s.schema_uid,
+//                                m.property_name,
+//                                m.property_value,
+//                                COUNT(v.local_id) as versions_count,
+//                                m.model_type,
+//                                lv.attestation_created_at,
+//                                m.local_id,
+//                                m.uid,
+//                                MAX(m.attestation_created_at),
+//                                m.ref_seed_type,
+//                                m.ref_value_type,
+//                                m.seed_local_id,
+//                                m.seed_uid,
+//                                m.created_at,
+//                                m.updated_at,
+//                                m.version_uid
+//                         FROM seeds s
+//                                  JOIN LatestMetadata lm ON s.local_id = m.seed_local_id
+//                                  JOIN LatestVersion lv ON lv.seed_local_id = m.seed_local_id
+//                                  JOIN metadata m ON m.property_name = lm.property_name OR lm.property_value = s.uid
+//                                  JOIN versions v ON s.local_id = v.seed_local_id
+//                         WHERE ${localIdWhere}
+//                            OR ${uidWhere}
+//                         GROUP BY m.property_name;
+// `
+//
+// const { rows } = await runQueryForStatement(queryStatement)
+//
+// const propertiesDataOld: PropertyData[] = []
+//
+// for (const row of rows) {
+//   propertiesDataOld.push({
+//     localId: row[0],
+//     uid: row[1],
+//     schemaUid: row[2],
+//     propertyName: row[3],
+//     propertyValue: row[4],
+//     versionsCount: row[5],
+//     itemModelName: row[6],
+//     attestationCreatedAt: row[7],
+//     metadataLocalId: row[8],
+//     metadataUid: row[9],
+//     metadataAttestationCreatedAt: row[10],
+//     refSeedType: row[11],
+//     refValueType: row[12],
+//     seedLocalId: row[13],
+//     seedUid: row[14],
+//     createdAt: row[15],
+//     updatedAt: row[16],
+//     versionUid: row[17],
+//   })
+// }
 
-const hydrateExistingItem = fromCallback(({ sendBack, input: { event, context } }) => {
-    const { existingItem } = event;
-    const { seedUid, seedLocalId, ModelClass } = context;
-    if (!ModelClass) {
-        throw new Error('ModelClass not found');
+const logger$4 = 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');
     }
-    const modelName = ModelClass.originalConstructor.name;
-    const _checkForItemOnAllItemsService = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!existingItem.seedLocalId && !existingItem.seedUid) {
-            console.warn('[singleItemActors] [hydrateExistingItem] No seedLocalId or seedUid found on existingItem');
-            return false;
-        }
-        if (!seedUid && !seedLocalId) {
-            return false;
+    if (seedUid && !seedLocalId) {
+        const seedData = yield getSeedData({ seedUid });
+        if (!seedData) {
+            logger$4('[db/queries] [getItem] no seedData seedUid', seedUid);
+            return;
         }
-        yield waitForEvent({
-            req: {
-                eventLabel: 'item.request',
-                data: {
-                    modelName,
-                    seedUid,
-                    seedLocalId,
-                    source: 'hydrateExistingItem',
-                },
-            },
-            res: {
-                eventLabel: `item.${modelName}.${seedLocalId}.response`,
-            },
-        });
-        return true;
-        // return new Promise((resolve) => {
-        // const timeStart = Date.now()
-        //
-        // const interval = setInterval(() => {
-        //   const timeElapsed = Date.now() - timeStart
-        //   if (timeElapsed > 2000) {
-        //     eventEmitter.emit('item.request', {
-        //       modelName,
-        //       versionUid,
-        //       versionLocalId,
-        //       source: 'hydrateExistingItem',
-        //     })
-        //   }
-        //   if (timeElapsed > 30000) {
-        //     clearInterval(interval)
-        //     console.error(
-        //       `[singleItemActors] [hydrateExistingItem] ${timeElapsed / 1000}s elapsed for ${modelName} ${versionLocalId}`,
-        //       context,
-        //     )
-        //     eventEmitter.removeListener(
-        //       `item.${modelName}.response`,
-        //       handleItemRequestResponse,
-        //     )
-        //     resolve(false)
-        //   }
-        // }, 500)
-        // const handleItemRequestResponse = (event) => {
-        //   if (
-        //     event.item &&
-        //     ((event.item.versionLocalId &&
-        //       event.item.versionLocalId === versionLocalId) ||
-        //       (event.item.versionUid && event.item.versionUid === versionUid))
-        //   ) {
-        //     clearInterval(interval)
-        //     eventEmitter.removeListener(
-        //       `item.${modelName}.response`,
-        //       handleItemRequestResponse,
-        //     )
-        //     resolve(true)
-        //   }
+        seedLocalId = seedData.localId;
+    }
+    const appDb = getAppDb();
+    const _b = getTableColumns(seeds), rest = __rest(_b, ["localId", "uid"]);
+    const whereClauses = [];
+    if (modelName) {
+        whereClauses.push(eq(seeds.type, modelName.toLowerCase()));
+    }
+    if (seedUid) {
+        whereClauses.push(eq(seeds.uid, seedUid));
+    }
+    if (seedLocalId && !seedUid) {
+        whereClauses.push(eq(seeds.localId, seedLocalId));
+    }
+    const versionData = getVersionData();
+    const itemDataRows = yield appDb
+        .with(versionData)
+        .select(Object.assign(Object.assign({}, rest), { seedLocalId: seeds.localId, seedUid: seeds.uid, versionsCount: versionData.versionsCount, lastVersionPublishedAt: versionData.lastVersionPublishedAt, latestVersionUid: versionData.latestVersionUid, latestVersionLocalId: versionData.latestVersionLocalId }))
+        .from(seeds)
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+        .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+        .groupBy(seeds.localId);
+    if (!itemDataRows || itemDataRows.length === 0) {
+        logger$4('[db/queries] [getItemDataFromDb] no itemDataRows');
+        return;
+    }
+    let itemData = itemDataRows[0];
+    const propertiesData = yield getItemProperties({ seedLocalId, seedUid });
+    // const initObj: ItemData = {
+    //   seedLocalId,
+    //   seedUid,
+    //   modelName,
+    // }
+    if (!propertiesData || propertiesData.length === 0) {
+        return itemData;
+    }
+    propertiesData[0];
+    for (const propertyData of propertiesData) {
+        const propertyName = propertyData.propertyName;
+        const propertyValue = propertyData.propertyValue;
+        // TODO: Find a better place for the property data below
+        // Since initObj is used to initialize an Item, the following values
+        // just overwrite each other for each property since they are Property
+        // specific.
+        // const refSeedType = propertyDbValues[11]
+        // if (refSeedType) {
+        //   initObj.refSeedType = refSeedType
         // }
-        //
-        // eventEmitter.addListener(
-        //   `item.${modelName}.response`,
-        //   handleItemRequestResponse,
-        // )
-        //
-        // eventEmitter.emit('item.request', {
-        //   modelName,
-        //   versionUid,
-        //   versionLocalId,
-        //   source: 'hydrateExistingItem',
-        // })
-        // })
-        // if (existingItem.versionLocalId && !existingItem.versionLocalId) {
-        //   console.log(
-        //     `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
-        //   )
-        //
-        //   return true
+        // const refValueType = propertyDbValues[12]
+        // if (refValueType) {
+        //   initObj.refValueType = refValueType
         // }
         //
-        // console.log(
-        //   `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
-        // )
-        // return true
-    });
-    _checkForItemOnAllItemsService().then((shouldContinue) => {
-        if (!shouldContinue) {
-            sendBack({ type: 'hydrateExistingItemFailure' });
-            return;
-        }
-        // for (const [key, value] of Object.entries(existingItem)) {
-        //   sendBack({
-        //     type: 'updateValue',
-        //     propertyName: key,
-        //     propertyValue: value,
-        //     source: 'db',
-        //   })
+        // if (
+        //   refSeedType &&
+        //   refValueType === 'list' &&
+        //   propertyName.endsWith('Ids')
+        // ) {
+        //   logger('[db/queries] [getItemDataFromDb] propertyName', propertyName)
         // }
-        sendBack({ type: 'hydrateExistingItemSuccess' });
-    });
+        itemData[propertyName] = propertyValue;
+    }
+    return itemData;
 });
 
-const hydrateNewItem = fromCallback(({ sendBack, input: { context } }) => {
-    const { seedUid, versionUid, modelName } = context;
-    let newSeedLocalId;
-    const _hydrateNewItem = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!modelName) {
-            throw new Error('modelName is required');
-        }
-        newSeedLocalId = yield createSeed({
-            type: modelName.toLowerCase(),
-            seedUid: seedUid !== null && seedUid !== void 0 ? seedUid : 'NULL',
-        });
-        yield createVersion({
-            seedLocalId: newSeedLocalId,
-            seedType: modelName.toLowerCase(),
-            uid: versionUid !== null && versionUid !== void 0 ? versionUid : 'NULL',
+var _a$1;
+class Item {
+    constructor(initialValues) {
+        this[_a$1] = true;
+        this._propertiesSubject = new BehaviorSubject({});
+        this.subscribe = (callback) => {
+            return this._service.subscribe((snapshot) => {
+                callback(snapshot.context);
+            });
+        };
+        this.getService = () => {
+            return this._service;
+        };
+        this.getEditedProperties = () => __awaiter(this, void 0, void 0, function* () {
+            return yield getItemProperties({
+                seedLocalId: this.seedLocalId,
+                edited: true,
+            });
         });
-    });
-    _hydrateNewItem().then(() => {
-        sendBack({ type: 'hydrateNewItemSuccess' });
-    });
-});
-
-const fetchDataFromEas = fromCallback(({ sendBack, input: { context } }) => {
-    const { ModelClass, modelTableName, versionUid } = context;
-    const propertiesMetadata = new Map();
-    // EAS is the final source of truth, so we need to see if our Item is
-    // already represented there. Then we need to intelligently sync/merge
-    // with whatever new data has been created on the device before the sync.
-    for (const [propertyName, propertyMetadata] of Object.entries(ModelClass.schema)) {
-        if (propertyMetadata) {
-            propertiesMetadata.set(propertyName, propertyMetadata);
-        }
-    }
-    sendBack({ type: 'updatePropertiesMetadata', propertiesMetadata });
-    if (!versionUid) {
-        // In this case this is a local only item, so we don't need to fetch anything
-        return;
-    }
-    const _fetchDataFromEas = () => __awaiter(void 0, void 0, void 0, function* () {
-        // Fetch Properties by versionUid
-        const { itemProperties } = yield queryClient.fetchQuery({
-            queryKey: ['getProperties', versionUid],
-            queryFn: () => __awaiter(void 0, void 0, void 0, function* () {
-                return easClient.request(GET_PROPERTIES, {
-                    where: {
-                        refUID: {
-                            in: [versionUid],
-                        },
-                        decodedDataJson: {
-                            not: {
-                                // The first of many filters to keep bad data out
-                                contains: '"value":"0x0000000000000000000000000000000000000000000000000000000000000020"',
-                            },
-                        },
+        this.publish = () => __awaiter(this, void 0, void 0, function* () {
+            yield waitForEvent({
+                req: {
+                    eventLabel: `item.publish.request`,
+                    data: {
+                        seedLocalId: this.seedLocalId,
                     },
-                });
-            }),
-        });
-        // Filter properties by schemaId
-        const selectedPropertiesMap = {};
-        itemProperties.forEach((property) => {
-            const existingProperties = selectedPropertiesMap[property.schemaId] || [];
-            existingProperties.push(property);
-            selectedPropertiesMap[property.schemaId] = existingProperties;
-        });
-        // For each schemaId, sort property Attestations by timeCreated DESC
-        Object.keys(selectedPropertiesMap).forEach((schemaId) => {
-            const sorted = selectedPropertiesMap[schemaId].sort((a, b) => {
-                return a.timeCreated - b.timeCreated;
+                },
+                res: {
+                    eventLabel: `item.${this.seedLocalId}.publish.success`,
+                },
             });
-            selectedPropertiesMap[schemaId] = sorted;
         });
-        Object.keys(selectedPropertiesMap).forEach((schemaId) => {
-            // TODO: Finish this logic
-            // console.log('[singleItemActors] [fetchDataFromEas] schemaId', schemaId)
-            // sendBack({ type: 'addPropertyAttestation', schemaId })
+        const { modelName, seedUid, schemaUid, seedLocalId, latestVersionLocalId, latestVersionUid, } = initialValues;
+        const ModelClass = getModel(modelName);
+        if (ModelClass &&
+            Object.keys(ModelClass === null || ModelClass === void 0 ? void 0 : ModelClass.schema).includes('storageTransactionId') &&
+            initialValues.storageTransactionId) {
+            this._storageTransactionId = initialValues.storageTransactionId;
+        }
+        this._service = createActor(itemMachineSingle, {
+            input: {
+                seedLocalId,
+                seedUid,
+                schemaUid,
+                ModelClass,
+                latestVersionLocalId,
+                latestVersionUid,
+                storageTransactionId: this._storageTransactionId,
+            },
         });
-        // Attach processed properties to the itemService/itemMachine context
-        sendBack({
-            type: 'updatedPropertiesBySchemaUid',
-            propertiesBySchemaUid: selectedPropertiesMap,
+        this._subscription = this._service.subscribe((snapshot) => {
+            const { context } = snapshot;
+            if (!context ||
+                !context.propertyInstances ||
+                context.propertyInstances.size === 0) {
+                return;
+            }
+            const propertiesObj = {};
+            for (const [key, propertyInstance] of context.propertyInstances) {
+                if (typeof key !== 'string' || internalPropertyNames.includes(key)) {
+                    propertiesObj[key.toString()] = propertyInstance;
+                    continue;
+                }
+                let transformedKey = key;
+                if (propertyInstance.alias) {
+                    transformedKey = propertyInstance.alias;
+                }
+                if (!propertyInstance.alias && key.endsWith('Ids')) {
+                    transformedKey = key.slice(0, -3); // Remove 'Ids'
+                    transformedKey = pluralize(transformedKey);
+                }
+                if (!propertyInstance.alias && key.endsWith('Id')) {
+                    transformedKey = key.slice(0, -2); // Remove 'Id'
+                }
+                propertiesObj[transformedKey] = propertyInstance;
+            }
+            this._propertiesSubject.next(propertiesObj);
+            eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
         });
-    });
-    _fetchDataFromEas().then(() => {
-        sendBack({ type: 'fetchDataFromEasSuccess' });
-    });
-});
-
-const itemMachineSingle = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        waitForDb,
-        initialize: initialize$2,
-        hydrateExistingItem,
-        hydrateNewItem,
-        fetchDataFromEas,
-    },
-}).createMachine({
-    id: MachineIds.ITEM,
-    initial: 'waitingForDb',
-    context: ({ input }) => input,
-    on: {
-        updatedPropertiesBySchemaUid: {
-            actions: assign({
-                propertiesBySchemaUid: ({ event }) => event.propertiesBySchemaUid,
-            }),
-        },
-        updatePropertiesMetadata: {
-            actions: assign({
-                propertiesMetadata: ({ event }) => event.propertiesMetadata,
-            }),
-        },
-        updateProperties: {
-            actions: assign({
-                propertiesUpdatedAt: Date.now(),
-            }),
-        },
-        updateValue: {
-            actions: assign(({ event, context }) => {
-                let { propertyInstances } = context;
-                if (!propertyInstances) {
-                    propertyInstances = new Map();
+        this._service.start();
+        const definedKeys = ['ModelClass'];
+        const itemPropertyBase = {
+            seedLocalId,
+            seedUid,
+            versionLocalId: latestVersionLocalId,
+            versionUid: latestVersionUid,
+            itemModelName: modelName,
+            schemaUid,
+        };
+        if (ModelClass && ModelClass.schema) {
+            const schema = ModelClass.schema;
+            for (const [propertyName, propertyRecordSchema] of Object.entries(schema)) {
+                if (!propertyRecordSchema) {
+                    throw new Error(`Property ${propertyName} has no definition`);
+                }
+                this._createPropertyInstance(Object.assign(Object.assign({}, itemPropertyBase), { propertyName, propertyValue: initialValues[propertyName] }));
+                definedKeys.push(propertyName);
+            }
+        }
+        Object.keys(initialValues).forEach((key) => {
+            // If we already defined it, that means it was in the schema
+            if (definedKeys.includes(key)) {
+                return;
+            }
+            this._createPropertyInstance(Object.assign(Object.assign({}, itemPropertyBase), { propertyName: key, propertyValue: initialValues[key] }));
+        });
+    }
+    static create(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!props.seedUid) {
+                console.log('Creating new item without seedUid');
+            }
+            if (props.seedUid || props.seedLocalId) {
+                const seedId = (props.seedUid || props.seedLocalId);
+                if (Item.instanceCache.has(seedId)) {
+                    const { instance, refCount } = Item.instanceCache.get(seedId);
+                    Item.instanceCache.set(seedId, {
+                        instance,
+                        refCount: refCount + 1,
+                    });
+                    return instance;
                 }
-                const { propertyName, propertyValue } = event;
-                if (!propertyInstances.has(propertyName)) {
-                    return {
-                        [propertyName]: propertyValue,
-                    };
+                if (!Item.instanceCache.has(seedId)) {
+                    const newInstance = new Item(props);
+                    Item.instanceCache.set(seedId, {
+                        instance: newInstance,
+                        refCount: 1,
+                    });
+                    return newInstance;
                 }
-                const propertyInstance = propertyInstances.get(propertyName);
-                propertyInstance.value = propertyValue;
-                propertyInstances.set(propertyName, propertyInstance);
-                // TODO: use immer here
-                return {
-                    propertyInstances,
-                };
-            }),
-        },
-        addPropertyInstance: {
-            actions: assign(({ context, event }) => {
-                const propertyInstances = context.propertyInstances || new Map();
-                propertyInstances.set(event.propertyName, event.propertyInstance);
-                return {
-                    propertyInstances,
-                };
-            }),
-        },
-        // addPropertyAttestation: {
-        //   actions: assign(({ context, event }) => {
-        //     console.log('[singleItemMachine] [addPropertyAttestation] event', event)
-        //     const propertyInstances =
-        //       context.propertyInstances || new Map<string, typeof ItemProperty>()
-        //     propertyInstances.set(event.propertyName, event.propertyInstances)
-        //     return {
-        //       propertyInstances,
-        //     }
-        //   }),
-        // },
-    },
-    states: {
-        idle: {},
-        waitingForDb: {
-            on: {
-                waitForDbSuccess: 'initializing',
-            },
-            invoke: {
-                src: 'waitForDb',
-            },
-        },
-        initializing: {
-            on: {
-                hasExistingItem: {
-                    target: 'idle',
-                    actions: assign({
-                        modelTableName: ({ event }) => event.modelTableName,
-                        modelNamePlural: ({ event }) => event.modelNamePlural,
-                        modelName: ({ event }) => event.modelName,
-                        existingItem: ({ event }) => event.existingItem,
-                    }),
+            }
+            if (!props.modelName) {
+                throw new Error('Model name is required to create an item');
+            }
+            const { seedLocalId } = yield createNewItem({
+                modelName: props.modelName,
+            });
+            props.seedLocalId = seedLocalId;
+            const newInstance = new Item(props);
+            Item.instanceCache.set(newInstance.seedUid || newInstance.seedLocalId, {
+                instance: newInstance,
+                refCount: 1,
+            });
+            return newInstance;
+        });
+    }
+    static find(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ modelName, seedLocalId, seedUid, }) {
+            if (!seedLocalId && !seedUid) {
+                return;
+            }
+            const itemData = yield getItemDataFromDb({
+                modelName,
+                seedLocalId,
+                seedUid,
+            });
+            if (!itemData) {
+                console.error('No item data found', { modelName, seedLocalId, seedUid });
+                return;
+            }
+            return Item.create(Object.assign(Object.assign({}, itemData), { modelName }));
+        });
+    }
+    static all(modelName, deleted) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemsData = yield getItemsData({ modelName, deleted });
+            const itemInstances = [];
+            for (const itemData of itemsData) {
+                itemInstances.push(yield Item.create(Object.assign(Object.assign({}, itemData), { modelName })));
+            }
+            return orderBy(itemInstances, ['createdAt'], ['desc']);
+        });
+    }
+    static publish(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield waitForEvent({
+                req: {
+                    eventLabel: `item.${item.seedLocalId}.publish.request`,
+                    data: {
+                        seedLocalId: item.seedLocalId,
+                    },
                 },
-                isNewItem: {
-                    target: 'idle',
-                    actions: assign({
-                        modelTableName: ({ event }) => event.modelTableName,
-                        modelNamePlural: ({ event }) => event.modelNamePlural,
-                        modelName: ({ event }) => event.modelName,
-                    }),
+                res: {
+                    eventLabel: `item.${item.seedLocalId}.publish.success`,
                 },
-            },
-            invoke: {
-                src: 'initialize',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-        hydratingExistingItem: {
-            on: {
-                hydrateExistingItemSuccess: 'idle',
-                hydrateExistingItemFailure: 'destroying',
-            },
-            invoke: {
-                src: 'hydrateExistingItem',
-                input: ({ event, context }) => ({ event, context }),
-            },
-        },
-        hydratingNewItem: {
-            on: {
-                hydrateNewItemSuccess: 'idle',
-            },
-            invoke: {
-                src: 'hydrateNewItem',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        fetchingRemoteData: {
-            on: {
-                fetchRemoteDataSuccess: 'idle',
-            },
-            invoke: {
-                src: 'fetchRemoteData',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        // fetchingDataFromEas: {
-        //   on: {
-        //     fetchDataFromEasSuccess: 'savingDataToDb',
-        //   },
-        //   invoke: {
-        //     src: 'fetchDataFromEas',
-        //     input: ({ context }) => ({ context }),
-        //   },
-        // },
-        // savingDataToDb: {
-        //   on: {
-        //     saveDataToDbSuccess: 'idle',
-        //   },
-        //   invoke: {
-        //     src: 'saveDataToDb',
-        //     input: ({ context }) => ({ context }),
-        //   },
-        // },
-        destroying: {
-            type: 'final',
-        },
-    },
-});
+            });
+        });
+    }
+    _createPropertyInstance(props) {
+        if (this._storageTransactionId) {
+            props.storageTransactionId = this._storageTransactionId;
+        }
+        const propertyInstance = ItemProperty.create(props);
+        if (!propertyInstance) {
+            return;
+        }
+        if (!propertyInstance.alias) {
+            this._service.send({
+                type: 'addPropertyInstance',
+                propertyName: props.propertyName,
+                propertyInstance,
+            });
+        }
+        Object.defineProperty(this, props.propertyName, {
+            get: () => propertyInstance.value,
+            set: (value) => (propertyInstance.value = value),
+            enumerable: true,
+        });
+    }
+    get seedLocalId() {
+        return this._service.getSnapshot().context.seedLocalId;
+    }
+    get seedUid() {
+        return this._service.getSnapshot().context.seedUid;
+    }
+    get schemaUid() {
+        return this.properties['schemaUid'].value;
+    }
+    get latestVersionUid() {
+        return this.properties['latestVersionUid'].value;
+    }
+    get modelName() {
+        return this._service.getSnapshot().context.modelName;
+    }
+    get properties() {
+        return this._propertiesSubject.value;
+    }
+    unload() {
+        var _b;
+        (_b = this._subscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        this._service.stop();
+    }
+}
+_a$1 = immerable;
+Item.instanceCache = new Map();
 
-const getItemProperties = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, edited, }) {
-    const appDb = getAppDb();
-    const whereClauses = [isNotNull(metadata.propertyName)];
-    const uidWhereClause = seedUid
-        ? eq(seeds.uid, seedUid)
-        : isNull(seeds.uid);
-    const localWhereClause = seedLocalId
-        ? eq(seeds.localId, seedLocalId)
-        : isNull(seeds.localId);
-    whereClauses.push(or(localWhereClause, uidWhereClause));
-    whereClauses.push(isNotNull(metadata.propertyName));
-    whereClauses.push(isNotNull(metadata.easDataType));
-    if (typeof edited !== 'undefined') {
-        if (edited) {
-            whereClauses.push(isNull(metadata.uid));
+const logger$3 = debug('app:react:services');
+const finalStrings = ['idle', 'ready', 'done', 'success'];
+const getServiceName = (service) => {
+    let name = 'actor';
+    if (service && service.uniqueKey) {
+        name = service.uniqueKey;
+    }
+    if (service && !service.uniqueKey && service.logic && service.logic.config) {
+        name = getServiceUniqueKey(service);
+    }
+    return name;
+};
+const getServiceValue = (service) => {
+    let value;
+    if (service && service.getSnapshot() && service.getSnapshot().value) {
+        value = service.getSnapshot().value;
+    }
+    if (getServiceName(service) === 'global') {
+        if (value &&
+            typeof value === 'object' &&
+            Object.keys(value).length > 0 &&
+            Object.keys(value)[0] === 'initialized') {
+            value = 'ready';
         }
-        if (!edited) {
-            whereClauses.push(isNotNull(metadata.uid));
+    }
+    if (value && typeof value === 'object') {
+        value = JSON.stringify(value);
+    }
+    return value;
+};
+const getServiceUniqueKey = (service) => {
+    if (!service || !service.logic || !service.logic.config) {
+        return;
+    }
+    const config = service.logic.config;
+    if (!config.id) {
+        return;
+    }
+    let uniqueKey = config.id;
+    if (config.id.includes('@seedSdk/')) {
+        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
+    }
+    let snapshot;
+    try {
+        snapshot = service.getSnapshot();
+    }
+    catch (error) {
+        logger$3('Error:', error);
+        return uniqueKey;
+    }
+    if (snapshot) {
+        const context = snapshot.context;
+        if (context && context.dbName) {
+            uniqueKey = context.dbName;
+        }
+        if (context && context.modelNamePlural) {
+            uniqueKey = context.modelNamePlural;
+        }
+        if (context && context.modelName) {
+            uniqueKey = pluralize(context.modelName.toLowerCase());
         }
     }
-    // if (!seedLocalId || !seedUid) {
-    //   const seedRows = await appDb
-    //     .select({
-    //       localId: seeds.localId,
-    //       uid: seeds.uid,
-    //     })
-    //     .from(seeds)
-    //     .where(or(localWhereClause, uidWhereClause))
-    //
-    //   if (seedRows && seedRows.length > 0) {
-    //     seedUid = seedRows[0].uid as string
-    //     seedLocalId = seedRows[0].localId as string
-    //   }
-    // }
-    const metadataColumns = getTableColumns(metadata);
-    const propertiesData = yield appDb
-        .select(Object.assign({}, metadataColumns))
-        .from(seeds)
-        .leftJoin(metadata, eq(metadata.seedLocalId, seeds.localId))
-        .leftJoin(versions, eq(versions.localId, seeds.localId))
-        .where(and(...whereClauses))
-        .groupBy(metadata.propertyName);
-    return propertiesData;
-});
-// const localIdWhere = seedLocalId
-//   ? `s.local_id = '${seedLocalId}'`
-//   : 's.local_id IS NULL'
-// const uidWhere = seedUid ? `s.uid = '${seedUid}'` : 's.uid IS NULL'
-//
-// const queryStatement = `WITH LatestMetadata as (SELECT m.property_name,
-//                                                        m.property_value,
-//                                                        m.version_local_id,
-//                                                        MAX(m.attestation_created_at),
-//                                                        m.uid,
-//                                                        m.seed_local_id,
-//                                                        seed_uid
-//                                                 FROM metadata m
-//                                                          JOIN seeds s ON s.local_id = m.seed_local_id
-//                                                 GROUP BY m.property_name),
-//
-//                              LatestVersion as (SELECT v.local_id,
-//                                                       MAX(v.attestation_created_at) as attestation_created_at,
-//                                                       v.uid,
-//                                                       v.seed_local_id,
-//                                                       v.seed_uid
-//                                                FROM versions v
-//                                                         JOIN seeds s ON s.local_id = v.seed_local_id
-//                                                GROUP BY s.local_id)
-//
-//
-//                         SELECT s.local_id,
-//                                s.uid,
-//                                s.schema_uid,
-//                                m.property_name,
-//                                m.property_value,
-//                                COUNT(v.local_id) as versions_count,
-//                                m.model_type,
-//                                lv.attestation_created_at,
-//                                m.local_id,
-//                                m.uid,
-//                                MAX(m.attestation_created_at),
-//                                m.ref_seed_type,
-//                                m.ref_value_type,
-//                                m.seed_local_id,
-//                                m.seed_uid,
-//                                m.created_at,
-//                                m.updated_at,
-//                                m.version_uid
-//                         FROM seeds s
-//                                  JOIN LatestMetadata lm ON s.local_id = m.seed_local_id
-//                                  JOIN LatestVersion lv ON lv.seed_local_id = m.seed_local_id
-//                                  JOIN metadata m ON m.property_name = lm.property_name OR lm.property_value = s.uid
-//                                  JOIN versions v ON s.local_id = v.seed_local_id
-//                         WHERE ${localIdWhere}
-//                            OR ${uidWhere}
-//                         GROUP BY m.property_name;
-// `
-//
-// const { rows } = await runQueryForStatement(queryStatement)
-//
-// const propertiesDataOld: PropertyData[] = []
-//
-// for (const row of rows) {
-//   propertiesDataOld.push({
-//     localId: row[0],
-//     uid: row[1],
-//     schemaUid: row[2],
-//     propertyName: row[3],
-//     propertyValue: row[4],
-//     versionsCount: row[5],
-//     itemModelName: row[6],
-//     attestationCreatedAt: row[7],
-//     metadataLocalId: row[8],
-//     metadataUid: row[9],
-//     metadataAttestationCreatedAt: row[10],
-//     refSeedType: row[11],
-//     refValueType: row[12],
-//     seedLocalId: row[13],
-//     seedUid: row[14],
-//     createdAt: row[15],
-//     updatedAt: row[16],
-//     versionUid: row[17],
-//   })
-// }
+    return uniqueKey;
+};
+const useIsDbReady = () => {
+    const [isDbReady, setIsDbReady] = useState(false);
+    const { internalStatus } = useGlobalServiceStatus();
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            setIsDbReady(true);
+        }
+    }, [internalStatus]);
+    return isDbReady;
+};
+const useServices = () => {
+    const [actors, setActors] = useState([]);
+    const [percentComplete, setPercentComplete] = useState(5);
+    const actorsMap = new Map();
+    useEffect(() => {
+        const globalServiceListener = (event) => {
+            if (event && event.type === 'init') {
+                return;
+            }
+            if (event.actorRef &&
+                event.actorRef.logic &&
+                event.actorRef.logic.config) {
+                const service = event.actorRef;
+                const services = [service];
+                if (service.logic.config.id === MachineIds.GLOBAL) {
+                    const context = service.getSnapshot().context;
+                    const keys = Object.keys(context);
+                    for (const key of keys) {
+                        if (!key.startsWith('internal') && key.endsWith('Service')) {
+                            const allItemsService = context[key];
+                            services.push(allItemsService);
+                        }
+                    }
+                }
+                services.forEach((innerService) => {
+                    const uniqueKey = getServiceUniqueKey(innerService);
+                    if (!uniqueKey) {
+                        return;
+                    }
+                    innerService.uniqueKey = uniqueKey;
+                    actorsMap.set(uniqueKey, innerService);
+                });
+                let actorsArray = Array.from(actorsMap.values());
+                actorsArray = orderBy(actorsArray, (a) => a.logic.config.id, ['asc']);
+                setActors(produce(actors, (draft) => {
+                    return actorsArray;
+                }));
+            }
+        };
+        eventEmitter.addListener('inspect.globalService', globalServiceListener);
+        return () => {
+            eventEmitter.removeListener('inspect.globalService', globalServiceListener);
+        };
+    }, []);
+    useEffect(() => {
+        const globalService = actors.find((actor) => getServiceName(actor) === 'global');
+        const internalService = actors.find((actor) => getServiceName(actor) === 'internal');
+        if (!globalService || !internalService) {
+            return;
+        }
+        if (getServiceValue(globalService) === 'ready' &&
+            getServiceValue(internalService) === 'ready') {
+            const denominator = actors.length;
+            const finishedActors = actors.filter((actor) => {
+                const value = getServiceValue(actor);
+                return finalStrings.includes(value);
+            });
+            const numerator = finishedActors.length;
+            const percentComplete = (numerator / denominator) * 100;
+            setPercentComplete(percentComplete);
+        }
+    }, [actors]);
+    return {
+        services: actors,
+        percentComplete,
+    };
+};
+const useGlobalServiceStatus = () => {
+    const globalService = getGlobalService();
+    const status = useSelector(globalService, (snapshot) => {
+        return snapshot.value;
+    });
+    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
+        if (!snapshot) {
+            return;
+        }
+        return snapshot.value;
+    });
+    useSelector(globalService, (snapshot) => {
+        return snapshot.context.internalService;
+    });
+    return {
+        status,
+        internalStatus,
+    };
+};
 
-var _a$1;
-class Item {
-    constructor(initialValues) {
-        this[_a$1] = true;
-        this._propertiesSubject = new BehaviorSubject({});
-        this.subscribe = (callback) => {
-            return this._service.subscribe((snapshot) => {
-                callback(snapshot.context);
-            });
-        };
-        this.getService = () => {
-            return this._service;
-        };
-        this.getEditedProperties = () => __awaiter(this, void 0, void 0, function* () {
-            return yield getItemProperties({
-                seedLocalId: this.seedLocalId,
-                edited: true,
-            });
-        });
-        this.publish = () => __awaiter(this, void 0, void 0, function* () {
-            yield waitForEvent({
-                req: {
-                    eventLabel: `item.publish.request`,
-                    data: {
-                        seedLocalId: this.seedLocalId,
-                    },
-                },
-                res: {
-                    eventLabel: `item.${this.seedLocalId}.publish.success`,
-                },
+const logger$2 = debug('app:react:item');
+const useItem = ({ modelName, seedLocalId, seedUid }) => {
+    const [itemData, setItemData] = useImmer({});
+    const [item, setItem] = useState();
+    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) => {
+        setItemData((draft) => {
+            Object.keys(newItem.properties).forEach((propertyName) => {
+                const value = newItem[propertyName];
+                draft[propertyName] = value;
             });
         });
-        const { modelName, seedUid, schemaUid, seedLocalId, latestVersionLocalId, latestVersionUid, } = initialValues;
-        const ModelClass = getModel(modelName);
-        if (ModelClass &&
-            Object.keys(ModelClass === null || ModelClass === void 0 ? void 0 : ModelClass.schema).includes('storageTransactionId') &&
-            initialValues.storageTransactionId) {
-            this._storageTransactionId = initialValues.storageTransactionId;
+    }, []);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingDb.current ||
+            internalStatus !== 'ready' ||
+            (!seedUid && !seedLocalId)) {
+            return;
         }
-        this._service = createActor(itemMachineSingle, {
-            input: {
-                seedLocalId,
-                seedUid,
-                schemaUid,
-                ModelClass,
-                latestVersionLocalId,
-                latestVersionUid,
-                storageTransactionId: this._storageTransactionId,
-            },
+        isReadingDb.current = true;
+        const foundItem = yield Item.find({
+            modelName,
+            seedLocalId,
+            seedUid,
         });
-        this._subscription = this._service.subscribe((snapshot) => {
-            const { context } = snapshot;
-            if (!context ||
-                !context.propertyInstances ||
-                context.propertyInstances.size === 0) {
-                return;
-            }
-            const propertiesObj = {};
-            for (const [key, propertyInstance] of context.propertyInstances) {
-                if (typeof key !== 'string' || internalPropertyNames.includes(key)) {
-                    propertiesObj[key.toString()] = propertyInstance;
-                    continue;
-                }
-                let transformedKey = key;
-                if (propertyInstance.alias) {
-                    transformedKey = propertyInstance.alias;
-                }
-                if (!propertyInstance.alias && key.endsWith('Ids')) {
-                    transformedKey = key.slice(0, -3); // Remove 'Ids'
-                    transformedKey = pluralize(transformedKey);
-                }
-                if (!propertyInstance.alias && key.endsWith('Id')) {
-                    transformedKey = key.slice(0, -2); // Remove 'Id'
+        if (!foundItem) {
+            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            return;
+        }
+        setItem(foundItem);
+        updateItem(foundItem);
+        isReadingDb.current = false;
+    }), [internalStatus]);
+    const listenerRef = useRef(readFromDb);
+    useEffect(() => {
+        listenerRef.current = readFromDb;
+    }, [readFromDb]);
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            listenerRef.current();
+        }
+    }, [internalStatus, status]);
+    useEffect(() => {
+        if (item && !itemSubscription) {
+            const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
+                const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
+                if (!newItem) {
+                    logger$2('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    return;
                 }
-                propertiesObj[transformedKey] = propertyInstance;
-            }
-            this._propertiesSubject.next(propertiesObj);
-            eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
+                updateItem(newItem);
+                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`, () => {
+            listenerRef.current();
         });
-        this._service.start();
-        const definedKeys = ['ModelClass'];
-        const itemPropertyBase = {
+        return () => {
+            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
+        };
+    }, []);
+    return {
+        item,
+        itemData,
+        itemStatus,
+    };
+};
+const useItems = ({ modelName, deleted }) => {
+    const [items, setItems] = useImmer([]);
+    const [isReadingDb, setIsReadingDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const isDbReady = useIsDbReady();
+    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, deleted);
+        setItems(() => allItems);
+        setIsReadingDb(false);
+    }), [modelName, isReadingDb]);
+    useEffect(() => {
+        if (isDbReady && !isInitialized) {
+            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
+                yield readFromDb({ modelName });
+                setIsInitialized(true);
+            });
+            _fetchItems();
+        }
+    }, [isInitialized, isDbReady]);
+    useEffect(() => {
+        eventEmitter.addListener('item.requestAll', readFromDb);
+        return () => {
+            eventEmitter.removeListener('item.requestAll');
+        };
+    }, []);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']).slice(0, 10),
+        isReadingDb,
+        isInitialized,
+    };
+};
+const useItemIsReady = () => {
+    const [itemListenersReady, setItemListenersReady] = useState(false);
+    const itemEventListenersHandler = useCallback((_) => {
+        setItemListenersReady(true);
+    }, []);
+    useEffect(() => {
+        const areReady = getAreItemEventHandlersReady();
+        if (areReady) {
+            itemEventListenersHandler(true);
+        }
+        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
+        return () => {
+            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
+        };
+    }, []);
+    return {
+        isReady: itemListenersReady,
+    };
+};
+const useCreateItem = (modelName) => {
+    const [isCreatingItem, setIsCreatingItem] = useState(false);
+    const { isReady } = useItemIsReady();
+    const createItem = useCallback((itemData) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!isReady) {
+            console.error(`[useCreateItem] [createItem] called before listeners are ready`, itemData);
+            return;
+        }
+        if (isCreatingItem) {
+            // TODO: should we setup a queue for this?
+            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
+            return;
+        }
+        setIsCreatingItem(true);
+        const { seedLocalId } = yield createNewItem(Object.assign({ modelName }, itemData));
+        yield Item.find({ modelName, seedLocalId });
+        eventEmitter.emit('item.requestAll', { modelName });
+        setIsCreatingItem(false);
+    }), [isCreatingItem, isReady]);
+    return {
+        createItem,
+        isCreatingItem,
+    };
+};
+
+const logger$1 = debug('app:react:property');
+const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
+    const [property, setProperty] = useState();
+    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    // const isDbReady = useMemo(() => useIsDbReady(), [])
+    const { internalStatus } = useGlobalServiceStatus();
+    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 (property && property.value !== value) {
+    //     readFromDb()
+    //   }
+    // }, [property, value])
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (internalStatus !== 'ready' ||
+            isReadingFromDb ||
+            (!seedLocalId && !seedUid)) {
+            return;
+        }
+        setIsReadingFromDb(true);
+        const foundProperty = yield ItemProperty.find({
+            propertyName,
             seedLocalId,
             seedUid,
-            versionLocalId: latestVersionLocalId,
-            versionUid: latestVersionUid,
-            itemModelName: modelName,
-            schemaUid,
-        };
-        if (ModelClass && ModelClass.schema) {
-            const schema = ModelClass.schema;
-            for (const [propertyName, propertyRecordSchema] of Object.entries(schema)) {
-                if (!propertyRecordSchema) {
-                    throw new Error(`Property ${propertyName} has no definition`);
-                }
-                this._createPropertyInstance(Object.assign(Object.assign({}, itemPropertyBase), { propertyName, propertyValue: initialValues[propertyName] }));
-                definedKeys.push(propertyName);
-            }
-        }
-        Object.keys(initialValues).forEach((key) => {
-            // If we already defined it, that means it was in the schema
-            if (definedKeys.includes(key)) {
-                return;
-            }
-            this._createPropertyInstance(Object.assign(Object.assign({}, itemPropertyBase), { propertyName: key, propertyValue: initialValues[key] }));
-        });
-    }
-    static create(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!props.seedUid) {
-                console.log('Creating new item without seedUid');
-            }
-            if (props.seedUid || props.seedLocalId) {
-                const seedId = (props.seedUid || props.seedLocalId);
-                if (Item.instanceCache.has(seedId)) {
-                    const { instance, refCount } = Item.instanceCache.get(seedId);
-                    Item.instanceCache.set(seedId, {
-                        instance,
-                        refCount: refCount + 1,
-                    });
-                    return instance;
-                }
-                if (!Item.instanceCache.has(seedId)) {
-                    const newInstance = new Item(props);
-                    Item.instanceCache.set(seedId, {
-                        instance: newInstance,
-                        refCount: 1,
-                    });
-                    return newInstance;
-                }
-            }
-            if (!props.modelName) {
-                throw new Error('Model name is required to create an item');
-            }
-            const { seedLocalId } = yield createNewItem({
-                modelName: props.modelName,
-            });
-            props.seedLocalId = seedLocalId;
-            const newInstance = new Item(props);
-            Item.instanceCache.set(newInstance.seedUid || newInstance.seedLocalId, {
-                instance: newInstance,
-                refCount: 1,
-            });
-            return newInstance;
         });
-    }
-    static find(_b) {
-        return __awaiter(this, arguments, void 0, function* ({ modelName, seedLocalId, seedUid, }) {
-            if (!seedLocalId && !seedUid) {
-                return;
-            }
-            const itemData = yield getItemDataFromDb({
-                modelName,
-                seedLocalId,
-                seedUid,
-            });
-            if (!itemData) {
-                console.error('No item data found', { modelName, seedLocalId, seedUid });
-                return;
-            }
-            if (!(itemData === null || itemData === void 0 ? void 0 : itemData.seedUid)) {
-                console.log('Item not found', { modelName, seedLocalId, seedUid });
-            }
-            return Item.create(Object.assign(Object.assign({}, itemData), { modelName }));
-        });
-    }
-    static all(modelName, deleted) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const itemsData = yield getItemsData({ modelName, deleted });
-            const itemInstances = [];
-            for (const itemData of itemsData) {
-                itemInstances.push(yield Item.create(Object.assign(Object.assign({}, itemData), { modelName })));
-            }
-            return orderBy(itemInstances, ['createdAt'], ['desc']);
-        });
-    }
-    static publish(item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield waitForEvent({
-                req: {
-                    eventLabel: `item.${item.seedLocalId}.publish.request`,
-                    data: {
-                        seedLocalId: item.seedLocalId,
-                    },
-                },
-                res: {
-                    eventLabel: `item.${item.seedLocalId}.publish.success`,
-                },
-            });
-        });
-    }
-    _createPropertyInstance(props) {
-        if (this._storageTransactionId) {
-            props.storageTransactionId = this._storageTransactionId;
+        setIsReadingFromDb(false);
+        if (!foundProperty) {
+            logger$1(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            return;
         }
-        const propertyInstance = ItemProperty.create(props);
-        if (!propertyInstance) {
+        if (foundProperty.status === 'waitingForDb') {
+            foundProperty.getService().send({ type: 'waitForDbSuccess' });
+        }
+        setProperty(foundProperty);
+        setIsInitialized(true);
+    }), [internalStatus, isReadingFromDb]);
+    // let count = 0
+    //
+    // const refresh = useCallback(() => {
+    //   count++
+    //   console.log('[useItemPropertyTest] [refresh] property', property)
+    // }, [property])
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            readFromDb();
+        }
+    }, [internalStatus]);
+    // useEffect(() => {
+    //   eventEmitter.addListener(
+    //     `property.${seedUid || seedLocalId}.${propertyName}.update`,
+    //     (event) => {
+    //       refresh()
+    //     },
+    //   )
+    //
+    //   return () => {
+    //     eventEmitter.removeListener(
+    //       `property.${seedUid || seedLocalId}.${propertyName}.update`,
+    //     )
+    //   }
+    // }, [])
+    return {
+        property,
+        isInitialized,
+        isReadingFromDb,
+        value,
+        status,
+    };
+};
+const useItemProperties = (item) => {
+    const [propertyObj, setPropertyObj] = useImmer({});
+    useState(false);
+    const updatePropertyObj = useCallback((event) => {
+        if (!item) {
+            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
             return;
         }
-        if (!propertyInstance.alias) {
-            this._service.send({
-                type: 'addPropertyInstance',
-                propertyName: props.propertyName,
-                propertyInstance,
-            });
+        const { propertyName, propertyValue } = event;
+        if (!propertyName) {
+            return;
         }
-        Object.defineProperty(this, props.propertyName, {
-            get: () => propertyInstance.value,
-            set: (value) => (propertyInstance.value = value),
-            enumerable: true,
+        setPropertyObj((draft) => {
+            draft[propertyName] = propertyValue;
         });
-    }
-    get seedLocalId() {
-        return this._service.getSnapshot().context.seedLocalId;
-    }
-    get seedUid() {
-        return this._service.getSnapshot().context.seedUid;
-    }
-    get schemaUid() {
-        return this.properties['schemaUid'].value;
-    }
-    get latestVersionUid() {
-        return this.properties['latestVersionUid'].value;
-    }
-    get modelName() {
-        return this._service.getSnapshot().context.modelName;
-    }
-    get properties() {
-        return this._propertiesSubject.value;
-    }
-    unload() {
-        var _b;
-        (_b = this._subscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
-        this._service.stop();
-    }
-}
-_a$1 = immerable;
-Item.instanceCache = new Map();
+    }, [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,
+    };
+};
+
+debug('app:react:db');
+
+const deleteItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid }) {
+    const appDb = getAppDb();
+    yield appDb
+        .update(seeds)
+        .set({
+        _markedForDeletion: 1,
+    })
+        .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)));
+});
+
+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 = debug('app:services:events');
+const handleServiceSaveState = (event) => {
+    const { state, serviceId } = event;
+    logger(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state));
+};
+const setupServicesEventHandlers = () => {
+    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
+};
 
-const logger = 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');
-    }
-    if (seedUid && !seedLocalId) {
-        const seedData = yield getSeedData({ seedUid });
-        if (!seedData) {
-            logger('[db/queries] [getItem] no seedData seedUid', seedUid);
-            return;
-        }
-        seedLocalId = seedData.localId;
-    }
-    const appDb = getAppDb();
-    const _b = getTableColumns(seeds), rest = __rest(_b, ["localId", "uid"]);
-    const whereClauses = [];
-    if (modelName) {
-        whereClauses.push(eq(seeds.type, modelName.toLowerCase()));
-    }
-    if (seedUid) {
-        whereClauses.push(eq(seeds.uid, seedUid));
-    }
-    if (seedLocalId && !seedUid) {
-        whereClauses.push(eq(seeds.localId, seedLocalId));
-    }
-    const versionData = getVersionData();
-    const itemDataRows = yield appDb
-        .with(versionData)
-        .select(Object.assign(Object.assign({}, rest), { seedLocalId: seeds.localId, seedUid: seeds.uid, versionsCount: versionData.versionsCount, lastVersionPublishedAt: versionData.lastVersionPublishedAt, latestVersionUid: versionData.latestVersionUid, latestVersionLocalId: versionData.latestVersionLocalId }))
-        .from(seeds)
-        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-        .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
-        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
-    if (!itemDataRows || itemDataRows.length === 0) {
-        logger('[db/queries] [getItemDataFromDb] no itemDataRows');
+const saveServiceHandler = (event) => __awaiter(void 0, void 0, void 0, function* () {
+    const globalService = getGlobalService();
+    if (!globalService || !globalService.getSnapshot().context) {
         return;
     }
-    let itemData = itemDataRows[0];
-    const propertiesData = yield getItemProperties({ seedLocalId, seedUid });
-    // const initObj: ItemData = {
-    //   seedLocalId,
-    //   seedUid,
-    //   modelName,
-    // }
-    if (!propertiesData || propertiesData.length === 0) {
-        return itemData;
-    }
-    propertiesData[0];
-    for (const propertyData of propertiesData) {
-        const propertyName = propertyData.propertyName;
-        const propertyValue = propertyData.propertyValue;
-        // TODO: Find a better place for the property data below
-        // Since initObj is used to initialize an Item, the following values
-        // just overwrite each other for each property since they are Property
-        // specific.
-        // const refSeedType = propertyDbValues[11]
-        // if (refSeedType) {
-        //   initObj.refSeedType = refSeedType
-        // }
-        // const refValueType = propertyDbValues[12]
-        // if (refValueType) {
-        //   initObj.refValueType = refValueType
-        // }
-        //
-        // if (
-        //   refSeedType &&
-        //   refValueType === 'list' &&
-        //   propertyName.endsWith('Ids')
-        // ) {
-        //   logger('[db/queries] [getItemDataFromDb] propertyName', propertyName)
-        // }
-        itemData[propertyName] = propertyValue;
-    }
-    return itemData;
+    const { modelName } = event;
+    const nameOfService = `${modelName}Service`;
+    const service = globalService.getSnapshot().context[nameOfService];
+    yield writeAppState(`snapshot__${modelName}`, JSON.stringify(service.getPersistedSnapshot()));
 });
 
+const setupServiceHandlers = () => {
+    eventEmitter.addListener('service.save', saveServiceHandler);
+};
+
+const client = {
+    init: ({ config, addresses }) => {
+        const { endpoints, models } = config;
+        for (const [key, value] of Object.entries(models)) {
+            setModel(key, value);
+        }
+        setupFsListeners();
+        setupAllItemsEventHandlers();
+        setupServicesEventHandlers();
+        setupServiceHandlers();
+        if (areFsListenersReady()) {
+            eventEmitter.emit('fs.init');
+        }
+        if (!areFsListenersReady()) {
+            console.error('fs listeners not ready during init');
+        }
+        globalService.send({ type: 'init', endpoints, models, addresses });
+        import('./seed.schema.config-BjnTnTUw.js').then(({ models }) => {
+            for (const [key, value] of Object.entries(models)) {
+                setModel(key, value);
+            }
+        });
+    },
+    subscribe: (callback) => {
+        callback({
+            type: '@xstate.snapshot',
+            actorRef: globalService,
+            snapshot: globalService.getSnapshot(),
+        });
+        eventEmitter.addListener('globalService', callback);
+        return {
+            unsubscribe: () => {
+                eventEmitter.removeListener('globalService', callback);
+            },
+        };
+    },
+    on: (outerEvent, callback) => {
+        eventEmitter.addListener(outerEvent, callback);
+        return {
+            unsubscribe: () => {
+                eventEmitter.removeListener(outerEvent, callback);
+            },
+        };
+    },
+    getSeedClass: () => __awaiter(void 0, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const subscription = globalService.subscribe((snapshot) => {
+                if (snapshot.status === 'done') {
+                    resolve(snapshot.output);
+                }
+            });
+            globalService.send({ type: 'getSeed' });
+            subscription.unsubscribe();
+        });
+    }),
+    getModel: (modelName) => {
+        return getModel(modelName);
+    },
+    getModels: () => {
+        return getModels();
+    },
+    getModelNames: () => {
+        return getModelNames();
+    },
+};
+
 const getItemPropertyData = (props) => __awaiter(void 0, void 0, void 0, function* () {
     const appDb = getAppDb();
     const whereClauses = [];
     const tableColumns = getTableColumns(metadata);
     for (const [propertyName, propertyValue] of Object.entries(props)) {
         if (Object.keys(tableColumns).includes(propertyName)) {
-            tableColumns[propertyName];
             whereClauses.push(eq(tableColumns[propertyName], propertyValue));
         }
     }
@@ -6635,142 +6867,141 @@ const getItemPropertyData = (props) => __awaiter(void 0, void 0, void 0, functio
     return queryRows[0];
 });
 
-const createMetadata = (metadataValues, propertyRecordSchema) => __awaiter(void 0, void 0, void 0, function* () {
-    const appDb = getAppDb();
-    metadataValues.localId = generateId();
-    if (propertyRecordSchema &&
-        propertyRecordSchema.localStorageDir &&
-        propertyRecordSchema.storageType === 'ItemStorage') {
-        metadataValues.refResolvedValue = `${metadataValues.localId}${propertyRecordSchema.filenameSuffix}`;
-        metadataValues.refValueType = 'file';
+const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, seedLocalId, seedUid, propertyName, propertyRecordSchema, itemModelName, propertyValue: existingValue, } = context;
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
     }
-    return appDb
-        .insert(metadata)
-        .values(Object.assign(Object.assign({}, metadataValues), { createdAt: Date.now(), updatedAt: Date.now() }))
-        .returning();
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
+    if (existingValue === newValue) {
+        sendBack({ type: 'saveValueToDbSuccess' });
+        return;
+    }
+    const _saveItemStorage = () => __awaiter(void 0, void 0, void 0, function* () {
+        // Save value to file
+        const appDb = getAppDb();
+        let propertyData;
+        if (localId) {
+            propertyData = yield getItemPropertyData({
+                localId,
+            });
+        }
+        if (!localId && seedLocalId) {
+            const itemData = yield getItemDataFromDb({
+                seedLocalId,
+            });
+            if (itemData) {
+                const whereClauses = [
+                    eq(metadata.propertyName, propertyName),
+                    eq(metadata.seedLocalId, seedLocalId),
+                ];
+                if (itemData.latestVersionLocalId) {
+                    whereClauses.push(eq(metadata.versionLocalId, itemData.latestVersionLocalId));
+                }
+                const queryRows = yield appDb
+                    .select()
+                    .from(metadata)
+                    .where(and(...whereClauses));
+                if (queryRows && queryRows.length) {
+                    propertyData = queryRows[0];
+                }
+                if (!propertyData) {
+                    const propertyDataRows = yield createMetadata({
+                        propertyName,
+                        modelType: itemModelName.toLowerCase(),
+                        seedLocalId,
+                        seedUid,
+                        versionLocalId: itemData.latestVersionLocalId,
+                        versionUid: itemData.latestVersionUid,
+                        localStorageDir: propertyRecordSchema.localStorageDir,
+                        refValueType: 'file',
+                    }, propertyRecordSchema);
+                    propertyData = propertyDataRows[0];
+                }
+                // propertyData = {
+                //   propertyName,
+                //   seedLocalId,
+                //   seedUid,
+                //   versionLocalId: itemData.latestVersionLocalId,
+                //   versionUid: itemData.latestVersionUid,
+                //   schemaUid: itemData.schemaUid,
+                // }
+            }
+        }
+        const localStorageDir = propertyRecordSchema.localStorageDir || propertyData.localStorageDir;
+        const fileName = propertyData.refResolvedValue ||
+            `${propertyData.seedLocalId}${propertyRecordSchema.filenameSuffix}`;
+        if (!localStorageDir || !fileName) {
+            throw new Error(`Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`);
+        }
+        const filePath = `/files/${localStorageDir}/${fileName}`;
+        yield fs.promises.writeFile(filePath, newValue);
+        yield appDb
+            .update(metadata)
+            .set({
+            refResolvedValue: fileName,
+        })
+            .where(eq(metadata.localId, propertyData.localId));
+        sendBack({
+            type: 'updateContext',
+            renderValue: newValue,
+        });
+        return true;
+    });
+    _saveItemStorage().then((success) => {
+        if (success) {
+            sendBack({ type: 'saveItemStorageSuccess' });
+        }
+    });
 });
 
-const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, seedLocalId, seedUid, versionLocalId, versionUid, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
-    let { newValue } = event;
+const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, seedLocalId, versionLocalId, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
     if (existingValue === newValue) {
         sendBack({ type: 'saveValueToDbSuccess' });
         return;
     }
-    const _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        let refResolvedValue;
-        let refResolvedDisplayValue;
-        let refSeedType;
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
+    }
+    const _analyzeInput = () => __awaiter(void 0, void 0, void 0, function* () {
         let propertyName = propertyNameRaw;
-        if (propertyRecordSchema && propertyRecordSchema.dataType === 'Relation') {
-            refResolvedValue = newValue;
-            if (!propertyName.endsWith('Id')) {
-                propertyName = `${propertyName}Id`;
-            }
-            let fileType;
-            const dirs = yield fs.promises.readdir('/files');
-            for (const dir of dirs) {
-                const files = yield fs.promises.readdir(`/files/${dir}`);
-                if (files.includes(newValue)) {
-                    fileType = dir;
-                    break;
-                }
-            }
-            if (fileType === 'images') {
-                const filePath = `/files/images/${newValue}`;
-                refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
-                refSeedType = 'image';
-                newValue = yield createSeed({
-                    type: refSeedType,
-                });
-                yield createVersion({
-                    seedLocalId,
-                    seedUid,
-                    seedType: refSeedType,
-                });
-            }
+        if (propertyRecordSchema.refValueType !== 'ImageSrc' &&
+            propertyRecordSchema.dataType === 'Relation') {
+            sendBack({
+                type: 'saveRelation',
+                newValue,
+            });
+            return false;
         }
-        if (propertyRecordSchema &&
-            propertyRecordSchema.storageType &&
+        if (propertyRecordSchema.refValueType === 'ImageSrc' ||
+            propertyRecordSchema.dataType === 'ImageSrc') {
+            sendBack({
+                type: 'saveImageSrc',
+                newValue,
+            });
+            return false;
+        }
+        if (propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            // Save value to file
-            const appDb = getAppDb();
-            let propertyData;
-            if (localId) {
-                propertyData = yield getItemPropertyData({
-                    localId,
-                });
-            }
-            if (!localId && seedLocalId) {
-                const itemData = yield getItemDataFromDb({
-                    seedLocalId,
-                });
-                if (itemData) {
-                    const whereClauses = [
-                        eq(metadata.propertyName, propertyName),
-                        eq(metadata.seedLocalId, seedLocalId),
-                    ];
-                    if (itemData.latestVersionLocalId) {
-                        whereClauses.push(eq(metadata.versionLocalId, itemData.latestVersionLocalId));
-                    }
-                    const queryRows = yield appDb
-                        .select()
-                        .from(metadata)
-                        .where(and(...whereClauses));
-                    if (queryRows && queryRows.length) {
-                        propertyData = queryRows[0];
-                    }
-                    if (!propertyData) {
-                        const propertyDataRows = yield createMetadata({
-                            propertyName,
-                            modelType: itemModelName.toLowerCase(),
-                            seedLocalId,
-                            seedUid,
-                            versionLocalId: itemData.latestVersionLocalId,
-                            versionUid: itemData.latestVersionUid,
-                            localStorageDir: propertyRecordSchema.localStorageDir,
-                            refValueType: 'file',
-                        }, propertyRecordSchema);
-                        propertyData = propertyDataRows[0];
-                    }
-                    // propertyData = {
-                    //   propertyName,
-                    //   seedLocalId,
-                    //   seedUid,
-                    //   versionLocalId: itemData.latestVersionLocalId,
-                    //   versionUid: itemData.latestVersionUid,
-                    //   schemaUid: itemData.schemaUid,
-                    // }
-                }
-            }
-            const localStorageDir = propertyRecordSchema.localStorageDir || propertyData.localStorageDir;
-            const fileName = propertyData.refResolvedValue ||
-                `${propertyData.localId}${propertyRecordSchema.filenameSuffix}`;
-            if (!localStorageDir || !fileName) {
-                throw new Error(`Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`);
-            }
-            const filePath = `/files/${localStorageDir}/${fileName}`;
-            yield fs.promises.writeFile(filePath, newValue);
-            yield appDb
-                .update(metadata)
-                .set({
-                refResolvedValue: fileName,
-            })
-                .where(eq(metadata.localId, propertyData.localId));
             sendBack({
-                type: 'updateContext',
-                renderValue: newValue,
+                type: 'saveItemStorage',
+                newValue,
             });
-            return;
+            return false;
         }
         yield updateItemPropertyValue({
             propertyLocalId: localId,
             propertyName,
             newValue,
             seedLocalId,
-            refSeedType,
-            refResolvedValue,
-            refResolvedDisplayValue,
             versionLocalId,
             modelName: itemModelName,
             schemaUid,
@@ -6778,11 +7009,13 @@ const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) =>
         sendBack({
             type: 'updateContext',
             propertyValue: newValue,
-            renderValue: refResolvedDisplayValue,
         });
+        return true;
     });
-    _saveValueToDb().then(() => {
-        sendBack({ type: 'saveValueToDbSuccess' });
+    _analyzeInput().then((isDone) => {
+        if (isDone) {
+            sendBack({ type: 'saveValueToDbSuccess' });
+        }
     });
 });
 
@@ -6790,6 +7023,7 @@ const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) =>
 const propertyMachine = setup({
     types: {
         context: {},
+        input: {},
     },
     // actions: {
     //   updateContext: updateMachineContext,
@@ -6800,7 +7034,10 @@ const propertyMachine = setup({
         initialize: initialize$3,
         resolveRelatedValue,
         resolveRemoteStorage,
-        saveValueToDb,
+        analyzeInput,
+        saveImageSrc,
+        saveRelation,
+        saveItemStorage,
     },
 }).createMachine({
     id: 'itemProperty',
@@ -6913,23 +7150,60 @@ const propertyMachine = setup({
             },
         },
         saving: {
-            on: {
-                saveValueToDbSuccess: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
+            initial: 'analyzingInput',
+            states: {
+                analyzingInput: {
+                    on: {
+                        saveValueToDbSuccess: {
+                            target: 'doneSaving',
+                        },
+                        saveImageSrc: 'savingImageSrc',
+                        saveRelation: 'savingRelation',
+                        saveItemStorage: 'savingItemStorage',
+                    },
+                    invoke: {
+                        src: 'analyzeInput',
+                        input: ({ context, event }) => ({ context, event }),
+                    },
                 },
-                saveValueToDbFailure: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
+                savingImageSrc: {
+                    on: {
+                        saveImageSrcSuccess: 'doneSaving',
+                    },
+                    invoke: {
+                        src: 'saveImageSrc',
+                        input: ({ context, event }) => ({ context, event }),
+                    },
+                },
+                savingRelation: {
+                    on: {
+                        saveRelationSuccess: 'doneSaving',
+                    },
+                    invoke: {
+                        src: 'saveRelation',
+                        input: ({ context, event }) => ({ context, event }),
+                    },
+                },
+                savingItemStorage: {
+                    on: {
+                        saveItemStorageSuccess: 'doneSaving',
+                    },
+                    invoke: {
+                        src: 'saveItemStorage',
+                        input: ({ context, event }) => ({ context, event }),
+                    },
+                },
+                doneSaving: {
+                    type: 'final',
                 },
             },
-            invoke: {
-                src: 'saveValueToDb',
-                input: ({ context, event }) => ({ context, event }),
+            onDone: {
+                target: 'idle',
+                actions: assign(({ context }) => {
+                    return {
+                        isSaving: false,
+                    };
+                }),
             },
         },
     },
@@ -7097,4 +7371,4 @@ if (isNode()) {
 }
 
 export { GET_SCHEMAS as G, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, GET_SEEDS as a, GET_SEED_IDS as b, GET_STORAGE_TRANSACTION_ID as c, GET_VERSIONS as d, GET_PROPERTIES as e, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as f, itemMachineAll as g, ImageSrc as h, itemMachineSingle as i, ItemProperty as j, useItem as k, useItemProperties as l, useCreateItem as m, useItemProperty as n, useDeleteItem as o, useGlobalServiceStatus as p, useServices as q, getGlobalService as r, client as s, getCorrectId as t, useItems as u, withSeed as w };
-//# sourceMappingURL=index-DQKd-s2Q.js.map
+//# sourceMappingURL=index-Cdz3ZpGp.js.map