@seedprotocol/sdk 0.1.53 → 0.1.55

package/dist/{index-DcXK4ERW.js → index-D4my8yy8.js}

@@ -2,8 +2,8 @@ import { b as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_
 import path, { basename } from 'path';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
-import { fromCallback, assign, setup, createActor, waitFor, emit, raise } from 'xstate';
-import { sql, relations, and, eq, max, or, inArray, like, isNotNull, isNull, count, desc, getTableColumns } from 'drizzle-orm';
+import { fromCallback, assign, createActor, waitFor, setup, emit, raise } from 'xstate';
+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';
 
@@ -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;
@@ -930,19 +935,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             }
             propertyNameQuery = or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, missingPropertyNameVariant));
         }
-        const selectFromStatement = db
-            .select({
-            localId: metadata.localId,
-            uid: metadata.uid,
-            propertyName: metadata.propertyName,
-            propertyValue: metadata.propertyValue,
-            seedLocalId: metadata.seedLocalId,
-            seedUid: metadata.seedUid,
-            schemaUid: metadata.schemaUid,
-            refResolvedValue: metadata.refResolvedValue,
-            refResolvedDisplayValue: metadata.refResolvedDisplayValue,
-        })
-            .from(metadata);
+        const selectFromStatement = db.select().from(metadata);
         if (seedUid && !seedLocalId) {
             hydrateQuery = selectFromStatement.where(and(eq(metadata.seedUid, seedUid), propertyNameQuery));
         }
@@ -960,7 +953,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         const firstRow = rows[0];
-        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, refResolvedValue, refResolvedDisplayValue, } = firstRow;
+        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, refResolvedValue, refResolvedDisplayValue, localStorageDir, } = firstRow;
         if (propertyName && !propertyNameFromDb) {
             logger$m(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
         }
@@ -987,13 +980,17 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             propertyValue: propertyValueFromDb,
             seedLocalId: seedLocalIdFromDb,
             seedUid: seedUidFromDb,
+            versionLocalId: versionLocalIdFromDb,
+            versionUid: versionUidFromDb,
             schemaUid: schemaUidFromDb,
-            resolveValue: refResolvedValue,
-            resolveDisplayValue: refResolvedDisplayValue,
+            refValueType,
+            localStorageDir,
+            resolvedValue: refResolvedValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
             renderValue: refResolvedDisplayValue,
         });
         if (propertyNameFromDb === 'storageTransactionId') {
-            const { Item } = yield import('./index-5a9z-kqT.js');
+            const { Item } = yield import('./index-BkzKfVvD.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1062,36 +1059,26 @@ const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoc
     return rows[0];
 });
 
-const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId }) {
-    const getVersionStatement = `SELECT local_id,
-                                      uid,
-                                      seed_local_id,
-                                      seed_uid,
-                                      seed_type,
-                                      note,
-                                      attestation_created_at,
-                                      attestation_raw,
-                                      created_at,
-                                      updated_at
-                               FROM versions
-                               WHERE local_id = '${seedLocalId}';`;
-    const { rows } = yield runQueryForStatement(getVersionStatement);
-    if (!rows || !rows.length) {
+const getVersionData$1 = (_a) => __awaiter(void 0, [_a], void 0, function* ({ localId, seedLocalId, uid, }) {
+    const appDb = getAppDb();
+    const whereClauses = [];
+    if (seedLocalId) {
+        whereClauses.push(eq(versions.localId, seedLocalId));
+    }
+    if (localId) {
+        whereClauses.push(eq(versions.localId, localId));
+    }
+    if (uid) {
+        whereClauses.push(eq(versions.uid, uid));
+    }
+    const queryRows = yield appDb
+        .select()
+        .from(versions)
+        .where(and(...whereClauses));
+    if (!queryRows || !queryRows.length) {
         return;
     }
-    const seedValues = rows[0];
-    return {
-        localId: seedValues[0],
-        uid: seedValues[1],
-        seedLocalId: seedValues[2],
-        seedUid: seedValues[3],
-        seedType: seedValues[4],
-        note: seedValues[5],
-        attestationCreatedAt: seedValues[6],
-        attestationRaw: seedValues[7],
-        createdAt: seedValues[8],
-        updatedAt: seedValues[9],
-    };
+    return queryRows[0];
 });
 
 const eventEmitter = new EventEmitter();
@@ -1110,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)) {
@@ -1129,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 {
@@ -1208,7 +1241,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
             return;
         }
         const seedDataFromDb = yield getSeedData({ seedLocalId });
-        const versionDataFromDb = yield getVersionData({ versionLocalId });
+        const versionDataFromDb = yield getVersionData$1({ versionLocalId });
         // Here we don't have a local-only record so we need to create a new one
         const newLocalId = generateId();
         const newPropertyStatement = `INSERT INTO metadata (local_id,
@@ -1252,7 +1285,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
         }
     }
     if (!versionUid) {
-        const versionData = yield getVersionData({ versionLocalId });
+        const versionData = yield getVersionData$1({ versionLocalId });
         if (versionData) {
             versionUid = versionData.uid;
         }
@@ -1435,234 +1468,262 @@ const updateMachineContext = {
     }),
 };
 
-const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, seedLocalId, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
-    let { newValue } = event;
+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 _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        let refResolvedValue;
-        let refResolvedDisplayValue;
-        let refSeedType;
+    const _saveImageSrc = () => __awaiter(void 0, void 0, void 0, function* () {
         let propertyName = propertyNameRaw;
-        let versionLocalId;
-        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,
-                });
-                versionLocalId = yield createVersion({
-                    seedLocalId: newValue,
-                    seedType: refSeedType,
-                });
+        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);
+        }
+        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]}`;
             }
         }
-        yield updateItemPropertyValue({
-            propertyLocalId: localId,
-            propertyName,
-            newValue,
-            seedLocalId,
-            refSeedType,
-            refResolvedValue,
-            refResolvedDisplayValue,
-            versionLocalId,
-            modelName: itemModelName,
-            schemaUid,
+        const filePath = `/files/images/${fileName}`;
+        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,
+                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: newValue,
+            propertyValue: newImageSeedLocalId,
+            refSeedType: 'image',
             renderValue: refResolvedDisplayValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
+            resolvedValue: fileName,
         });
     });
-    _saveValueToDb().then(() => {
-        sendBack({ type: 'saveValueToDbSuccess' });
+    _saveImageSrc().then(() => {
+        sendBack({ type: 'saveImageSrcSuccess' });
     });
 });
 
-const propertyMachine = setup({
-    types: {
-        context: {},
-    },
-    actors: {
-        waitForDb: waitForDb$1,
-        hydrateFromDb,
-        initialize: initialize$3,
-        resolveRelatedValue,
-        resolveRemoteStorage,
-        saveValueToDb,
-    },
-}).createMachine({
-    id: 'itemProperty',
-    initial: 'waitingForDb',
-    context: ({ input }) => input,
-    on: {
-        updatePropertyValue: {
-            target: '.resolvingRelatedValue',
-            guard: ({ context }) => !context.isDbReady,
-            actions: assign(({ event }) => {
-                return {
-                    propertyValue: event.propertyValue,
-                };
-            }),
-        },
-        updateRenderValue: {
-            actions: assign(({ event, context }) => {
-                return {
-                    renderValue: event.renderValue,
-                };
-            }),
-        },
-        save: {
-            actions: assign({
-                isSaving: true,
-            }),
-            target: '.saving',
-        },
-        updateContext: updateMachineContext,
-    },
-    states: {
-        idle: {},
-        waitingForDb: {
-            on: {
-                waitForDbSuccess: {
-                    target: 'hydratingFromDb',
-                    actions: assign({
-                        isDbReady: true,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'waitForDb',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        hydratingFromDb: {
-            on: {
-                hydrateFromDbSuccess: 'initializing',
-            },
-            invoke: {
-                src: 'hydrateFromDb',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        initializing: {
-            on: {
-                initializeSuccess: 'idle',
-                isRelatedProperty: {
-                    target: 'resolvingRelatedValue',
-                },
-                hasRemoteBackup: {
-                    target: 'resolvingRemoteStorage',
-                },
-            },
-            invoke: {
-                src: 'initialize',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-        resolvingRelatedValue: {
-            on: {
-                resolvingRelatedValueSuccess: {
-                    target: 'idle',
-                    actions: assign({
-                        resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
-                        resolvedValue: ({ event }) => event.resolvedValue,
-                    }),
-                },
-                resolvingRelatedValueDone: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'resolveRelatedValue',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        resolvingRemoteStorage: {
-            on: {
-                resolveRemoteStorageSuccess: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'resolveRemoteStorage',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        saving: {
-            on: {
-                saveValueToDbSuccess: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
-                },
-                saveValueToDbFailure: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'saveValueToDb',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-    },
-    // conflict: {
-    //   on: {
-    //     resolveConflict: {
-    //       target: 'saving',
-    //       actions: assign({
-    //         data: ({ context, event }) => event.output,
-    //       }),
-    //     },
-    //   },
-    // },
-});
-
-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);
-};
-
-var _a$2;
-const logger$k = debug('app:property:class');
-const namesThatEndWithId = [];
-class ItemProperty {
-    // private constructor(localIdOrUid) {
-    // }
-    constructor({ propertyValue, seedUid, seedLocalId, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
+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 = [];
+class ItemProperty {
+    // private constructor(localIdOrUid) {
+    // }
+    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
         this._isRelation = false;
         this._isList = false;
         this[_a$2] = true;
@@ -1673,12 +1734,13 @@ class ItemProperty {
         if (!propertyName) {
             throw new Error(`Property name not provided`);
         }
-        this._lastRenderedValue = propertyValue;
         const serviceInput = {
             propertyValue,
-            seedUid,
             propertyName,
             seedLocalId,
+            seedUid,
+            versionLocalId,
+            versionUid,
             itemModelName,
             storageTransactionId,
             propertyRecordSchema: ModelClass.schema[propertyName],
@@ -1723,8 +1785,12 @@ class ItemProperty {
         this._service = createActor(propertyMachine, {
             input: serviceInput,
         });
-        this._subscription = this._service.subscribe((snapshot) => {
+        this._subscription = this._service.subscribe((snapshot) => __awaiter(this, void 0, void 0, function* () {
+            if (!snapshot || !snapshot.context) {
+                return;
+            }
             const { context } = snapshot;
+            const { propertyRecordSchema } = context;
             // if (this.uid && !cacheHasProperty(this.uid)) {
             //   addPropertyToCache(this)
             // }
@@ -1746,7 +1812,21 @@ class ItemProperty {
                 //   this._updateResponseListener,
                 // )
             }
-            const renderValue = context.renderValue || context.propertyValue;
+            let renderValue;
+            if (propertyRecordSchema &&
+                propertyRecordSchema.storageType &&
+                propertyRecordSchema.storageType === 'ItemStorage' &&
+                context.resolvedValue &&
+                context.localStorageDir) {
+                const filePath = `/files/${context.localStorageDir}/${context.resolvedValue}`;
+                const exists = yield fs.promises.exists(filePath);
+                if (exists) {
+                    renderValue = yield fs.promises.readFile(filePath, 'utf-8');
+                }
+            }
+            if (!renderValue) {
+                renderValue = context.renderValue || context.propertyValue;
+            }
             let transformedPropertyName = propertyName;
             const skipTransform = internalPropertyNames.includes(propertyName) || !!this._alias;
             if (!skipTransform && transformedPropertyName.endsWith('Id')) {
@@ -1766,14 +1846,14 @@ class ItemProperty {
             if (context.seedUid) {
                 eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`);
             }
-        });
+        }));
         this._service.start();
     }
     _updateResponseListener(event) {
         logger$k(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
-        const { propertyName, seedLocalId, seedUid } = props;
+        const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
         if (!propertyName || (!seedLocalId && !seedUid)) {
             return;
         }
@@ -1842,32 +1922,35 @@ class ItemProperty {
     getService() {
         return this._service;
     }
+    _getSnapshot() {
+        return this._service.getSnapshot();
+    }
     get localId() {
-        return this._service.getSnapshot().context.localId;
+        return this._getSnapshot().context.localId;
     }
     get uid() {
-        return this._service.getSnapshot().context.uid;
+        return this._getSnapshot().context.uid;
     }
     get seedLocalId() {
-        return this._service.getSnapshot().context.seedLocalId;
+        return this._getSnapshot().context.seedLocalId;
     }
     get seedUid() {
-        return this._service.getSnapshot().context.seedUid;
+        return this._getSnapshot().context.seedUid;
     }
     get propertyName() {
         if (this._alias) {
             return this._alias;
         }
-        return this._service.getSnapshot().context.propertyName;
+        return this._getSnapshot().context.propertyName;
     }
     get itemModelName() {
-        return this._service.getSnapshot().context.itemModelName;
+        return this._getSnapshot().context.itemModelName;
     }
     get propertyDef() {
-        return this._service.getSnapshot().context.propertyRecordSchema;
+        return this._getSnapshot().context.propertyRecordSchema;
     }
     get status() {
-        return this._service.getSnapshot().value;
+        return this._getSnapshot().value;
     }
     get alias() {
         return this._alias;
@@ -1892,7 +1975,7 @@ class ItemProperty {
         });
     }
     get published() {
-        return !!this._service.getSnapshot().context.uid;
+        return !!this._getSnapshot().context.uid;
     }
     subscribe(callback) {
         return this._subject.subscribe(callback);
@@ -1921,84 +2004,6 @@ class ItemProperty {
 _a$2 = immerable;
 ItemProperty.instanceCache = new Map();
 
-const TPropertyDataType = Type.Union([
-    Type.Literal('Text'),
-    Type.Literal('Number'),
-    Type.Literal('List'),
-    Type.Literal('Relation'),
-    Type.Literal('ImageSrc'),
-    Type.Literal('FileSrc'),
-    Type.Literal('Json'),
-    Type.Literal('Blob'),
-]);
-const TStorageType = Type.Union([
-    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
-    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
-]);
-const TProperty = Type.Object({
-    id: Type.Optional(Type.Number()),
-    name: Type.Optional(Type.String()),
-    dataType: TPropertyDataType,
-    ref: Type.Optional(Type.String()),
-    modelId: Type.Optional(Type.Number()),
-    refModelId: Type.Optional(Type.Number()),
-    refValueType: Type.Optional(TPropertyDataType),
-    storageType: Type.Optional(TStorageType),
-    localStorageDir: Type.Optional(Type.String()),
-    filenameSuffix: Type.Optional(Type.String()),
-});
-const TPropertyConstructor = Type.Function([
-    Type.Optional(Type.Union([Type.String(), TStorageType])),
-    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
-    Type.Optional(Type.String()),
-], TProperty);
-Type.Record(TPropertyDataType, TPropertyConstructor);
-const Property = {
-    Text: (storageType, localStorageDir, filenameSuffix) => ({
-        dataType: 'Text',
-        storageType,
-        localStorageDir,
-        filenameSuffix,
-        TObject: Type.String(),
-    }),
-    Json: () => ({ dataType: 'Json' }),
-    Blob: () => ({ dataType: 'Blob' }),
-    Number: () => ({ dataType: 'Number' }),
-    List: (ref, refValueType) => ({
-        dataType: 'List',
-        ref,
-        refValueType,
-    }),
-    Relation: (ref, refValueType) => ({
-        dataType: 'Relation',
-        ref,
-        refValueType,
-    }),
-    ImageSrc: () => ({ dataType: 'ImageSrc' }),
-};
-const PropertyMetadataKey = Symbol('property');
-const PropertyConstructor = (propertyType) => {
-    return function (parentClassPrototype, propertyKey) {
-        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
-        existingProperties.push({ propertyKey, propertyType });
-        // console.log('existingProperties', existingProperties)
-        // console.log('propertyKey', propertyKey)
-        // console.log('propertyType', propertyType)
-        // console.log('PropertyMetadataKey', PropertyMetadataKey)
-        // console.log('typeof target', typeof target)
-        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
-        // console.log(
-        //   `After adding ${propertyKey}:`,
-        //   Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype),
-        // )
-    };
-};
-const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
-const Json = () => PropertyConstructor(Property.Json());
-const ImageSrc = () => PropertyConstructor(Property.ImageSrc());
-const Relation = (ref, refValueType) => PropertyConstructor(Property.Relation(ref, refValueType)); // Adjust for actual relation type
-const List = (ref, reValueType) => PropertyConstructor(Property.List(ref, reValueType)); // Adjust for actual list type
-
 const waitForDb = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -2553,7 +2558,7 @@ const createMetadataRecordsForStorageTransactionId = (storageTransactionIdProper
             versionLocalId,
             versionUid,
             refValueType: 'file',
-            refResolvedValue: `${propertyValue}.${propertyDef.filenameSuffix}`,
+            refResolvedValue: `${propertyValue}${propertyDef.filenameSuffix}`,
             modelType: seedUidToModelType.get(seedUid),
             createdAt: Date.now(),
             updatedAt: Date.now(),
@@ -2894,7 +2899,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-BtfzZOfM.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-BHZSMMmL.js');
         const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
@@ -3866,39 +3871,6 @@ const getArweave = () => {
     });
 };
 
-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)));
-    }
-    let query = appDb
-        .select({
-        seedLocalId: seeds.localId,
-        seedUid: seeds.uid,
-        schemaUid: seeds.schemaUid,
-        modelName: sql `${modelName}`,
-        attestationCreatedAt: seeds.attestationCreatedAt,
-        versionsCount: count(versions.localId),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt),
-        lastLocalUpdateAt: max(versions.createdAt),
-        createdAt: seeds.createdAt,
-    })
-        .from(seeds)
-        .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
-        .where(and(...conditions))
-        .orderBy(desc(seeds.createdAt))
-        .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;
@@ -4067,7 +4039,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;
@@ -5085,665 +5057,112 @@ 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;
-        }
-        if (context && context.modelNamePlural) {
-            uniqueKey = context.modelNamePlural;
-        }
-        if (context && context.modelName) {
-            uniqueKey = pluralize(context.modelName.toLowerCase());
+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;
         }
-    }
-    return uniqueKey;
-};
-const useIsDbReady = () => {
-    const [isDbReady, setIsDbReady] = useState(false);
-    const { internalStatus } = useGlobalServiceStatus();
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            setIsDbReady(true);
+        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;
         }
-    }, [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);
+        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: [],
         };
-    }, []);
-    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;
+        sendBack(Object.assign({ type: 'updateContext' }, publishRequestData));
+        return true;
     });
-    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
-        if (!snapshot) {
-            return;
+    _preparePublishRequestData().then((success) => {
+        if (success) {
+            sendBack({ type: 'preparePublishRequestDataSuccess' });
         }
-        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;
+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;
         }
-        isReadingDb.current = true;
-        const foundItem = yield Item.find({
-            modelName,
-            seedLocalId,
-            seedUid,
-        });
-        if (!foundItem) {
-            logger$4('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
-            return;
+        const editedProperties = yield item.getEditedProperties();
+        for (const propertyData of editedProperties) {
+            if (propertyData.refSeedType === 'image') ;
         }
-        setItem(foundItem);
-        updateItem(foundItem);
-        isReadingDb.current = false;
-    }), [internalStatus]);
-    const listenerRef = useRef(readFromDb);
-    useEffect(() => {
-        listenerRef.current = readFromDb;
-    }, [readFromDb]);
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            listenerRef.current();
+        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) ;
         }
-    }, [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);
+        if (uploadItems.length === 0) {
+            return true;
         }
-        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;
+        // const turbo = TurboFactory.unauthenticated()
+        // turbo.uploadSignedDataItem()
+        //
+        // const { id, owner, dataCaches, fastFinalityIndexes } = await turbo.uploadFile(() => {
+        //   fileStreamFactory => () => fs.createReadStream(filePath),
+        //   fileSizeFactory => () => fileSize,
+        // });
+        return false;
+    });
+    _upload().then((isValid) => {
+        if (isValid) {
+            sendBack({ type: 'uploadSuccess' });
         }
-        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$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) {
-            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)));
-});
-
-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);
-};
-
-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 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-BtfzZOfM.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 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;
-        }
-        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;
-        }
-        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' });
-        }
-    });
-});
-
-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) ;
-        }
-        if (uploadItems.length === 0) {
-            return true;
-        }
-        // const turbo = TurboFactory.unauthenticated()
-        // turbo.uploadSignedDataItem()
-        //
-        // const { id, owner, dataCaches, fastFinalityIndexes } = await turbo.uploadFile(() => {
-        //   fileStreamFactory => () => fs.createReadStream(filePath),
-        //   fileSizeFactory => () => fileSize,
-        // });
-        return false;
-    });
-    _upload().then((isValid) => {
-        if (isValid) {
-            sendBack({ type: 'uploadSuccess' });
-        }
-    });
-});
-
-const { VALIDATING_ITEM_DATA, CREATING_PUBLISH_ATTEMPT, PREPARING_PUBLISH_REQUEST_DATA, UPLOADING, PUBLISHING, IDLE, } = PublishMachineStates;
-const publishMachine = setup({
-    types: {
-        context: {},
-        input: {},
+const { VALIDATING_ITEM_DATA, CREATING_PUBLISH_ATTEMPT, PREPARING_PUBLISH_REQUEST_DATA, UPLOADING, PUBLISHING, IDLE, } = PublishMachineStates;
+const publishMachine = setup({
+    types: {
+        context: {},
+        input: {},
     },
     actors: {
         validateItemData,
@@ -6562,7 +5981,7 @@ const getItemProperties = (_a) => __awaiter(void 0, [_a], void 0, function* ({ s
 //   })
 // }
 
-const logger = debug('app:db:queries:getItem');
+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');
@@ -6570,7 +5989,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$4('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -6587,32 +6006,17 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedLocalId && !seedUid) {
         whereClauses.push(eq(seeds.localId, seedLocalId));
     }
-    // const uidWhereClause: SQL = seedUid
-    //   ? eq(seeds.uid, seedUid)
-    //   : isNull(seeds.uid)
-    // const localWhereClause: SQL = seedLocalId
-    //   ? eq(seeds.localId, seedLocalId)
-    //   : isNull(seeds.localId)
-    // whereClauses.push(or(localWhereClause, uidWhereClause) as SQL)
-    const latestVersions = appDb.$with('latestVersions').as(appDb
-        .select({
-        localId: versions.localId,
-        uid: versions.uid,
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-    })
-        .from(versions)
-        .groupBy(versions.seedLocalId));
+    const versionData = getVersionData();
     const itemDataRows = yield appDb
-        .with(latestVersions)
-        .select(Object.assign(Object.assign({}, rest), { seedLocalId: seeds.localId, seedUid: seeds.uid, versionsCount: count(versions.localId), lastVersionPublishedAt: max(versions.attestationCreatedAt), latestVersionUid: latestVersions.uid }))
+        .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(versions, eq(versions.seedLocalId, seeds.localId))
-        .leftJoin(latestVersions, eq(versions.seedLocalId, latestVersions.seedLocalId))
-        .where(and(...whereClauses))
+        .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');
+        logger$4('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -6686,7 +6090,7 @@ class Item {
                 },
             });
         });
-        const { modelName, seedUid, schemaUid, seedLocalId } = initialValues;
+        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') &&
@@ -6699,15 +6103,14 @@ class Item {
                 seedUid,
                 schemaUid,
                 ModelClass,
+                latestVersionLocalId,
+                latestVersionUid,
                 storageTransactionId: this._storageTransactionId,
             },
         });
         this._subscription = this._service.subscribe((snapshot) => {
             const { context } = snapshot;
-            if (
-            // snapshot.value === 'waitingForDb' ||
-            // snapshot.value === 'initializing' ||
-            !context ||
+            if (!context ||
                 !context.propertyInstances ||
                 context.propertyInstances.size === 0) {
                 return;
@@ -6739,6 +6142,8 @@ class Item {
         const itemPropertyBase = {
             seedLocalId,
             seedUid,
+            versionLocalId: latestVersionLocalId,
+            versionUid: latestVersionUid,
             itemModelName: modelName,
             schemaUid,
         };
@@ -6762,6 +6167,9 @@ class Item {
     }
     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)) {
@@ -6806,6 +6214,10 @@ class Item {
                 seedLocalId,
                 seedUid,
             });
+            if (!itemData) {
+                console.error('No item data found', { modelName, seedLocalId, seedUid });
+                return;
+            }
             return Item.create(Object.assign(Object.assign({}, itemData), { modelName }));
         });
     }
@@ -6882,6 +6294,1008 @@ class Item {
 _a$1 = immerable;
 Item.instanceCache = new Map();
 
+const logger$3 = debug('app:react:services');
+const finalStrings = ['idle', 'ready', 'done', 'success'];
+const getServiceName = (service) => {
+    let name = 'actor';
+    if (service && service.uniqueKey) {
+        name = service.uniqueKey;
+    }
+    if (service && !service.uniqueKey && service.logic && service.logic.config) {
+        name = getServiceUniqueKey(service);
+    }
+    return name;
+};
+const getServiceValue = (service) => {
+    let value;
+    if (service && service.getSnapshot() && service.getSnapshot().value) {
+        value = service.getSnapshot().value;
+    }
+    if (getServiceName(service) === 'global') {
+        if (value &&
+            typeof value === 'object' &&
+            Object.keys(value).length > 0 &&
+            Object.keys(value)[0] === 'initialized') {
+            value = 'ready';
+        }
+    }
+    if (value && typeof value === 'object') {
+        value = JSON.stringify(value);
+    }
+    return value;
+};
+const getServiceUniqueKey = (service) => {
+    if (!service || !service.logic || !service.logic.config) {
+        return;
+    }
+    const config = service.logic.config;
+    if (!config.id) {
+        return;
+    }
+    let uniqueKey = config.id;
+    if (config.id.includes('@seedSdk/')) {
+        uniqueKey = config.id.match(/^.*@seedSdk\/(\w+)[\.\w]*/)[1];
+    }
+    let snapshot;
+    try {
+        snapshot = service.getSnapshot();
+    }
+    catch (error) {
+        logger$3('Error:', error);
+        return uniqueKey;
+    }
+    if (snapshot) {
+        const context = snapshot.context;
+        if (context && context.dbName) {
+            uniqueKey = context.dbName;
+        }
+        if (context && context.modelNamePlural) {
+            uniqueKey = context.modelNamePlural;
+        }
+        if (context && context.modelName) {
+            uniqueKey = pluralize(context.modelName.toLowerCase());
+        }
+    }
+    return uniqueKey;
+};
+const 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,
+    };
+};
+
+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 readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingDb.current ||
+            internalStatus !== 'ready' ||
+            (!seedUid && !seedLocalId)) {
+            return;
+        }
+        isReadingDb.current = true;
+        const foundItem = yield Item.find({
+            modelName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!foundItem) {
+            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            return;
+        }
+        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;
+                }
+                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 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,
+        });
+        setIsReadingFromDb(false);
+        if (!foundProperty) {
+            logger$1(`[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)));
+});
+
+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 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 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-BHZSMMmL.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)) {
+            whereClauses.push(eq(tableColumns[propertyName], propertyValue));
+        }
+    }
+    const queryRows = yield appDb
+        .select()
+        .from(metadata)
+        .where(and(...whereClauses));
+    if (!queryRows || queryRows.length === 0) {
+        return;
+    }
+    return queryRows[0];
+});
+
+const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, seedLocalId, seedUid, propertyName, propertyRecordSchema, itemModelName, propertyValue: existingValue, } = context;
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
+    }
+    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 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;
+    }
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
+    }
+    const _analyzeInput = () => __awaiter(void 0, void 0, void 0, function* () {
+        let propertyName = propertyNameRaw;
+        if (propertyRecordSchema.refValueType !== 'ImageSrc' &&
+            propertyRecordSchema.dataType === 'Relation') {
+            sendBack({
+                type: 'saveRelation',
+                newValue,
+            });
+            return false;
+        }
+        if (propertyRecordSchema.refValueType === 'ImageSrc' ||
+            propertyRecordSchema.dataType === 'ImageSrc') {
+            sendBack({
+                type: 'saveImageSrc',
+                newValue,
+            });
+            return false;
+        }
+        if (propertyRecordSchema.storageType &&
+            propertyRecordSchema.storageType === 'ItemStorage') {
+            sendBack({
+                type: 'saveItemStorage',
+                newValue,
+            });
+            return false;
+        }
+        yield updateItemPropertyValue({
+            propertyLocalId: localId,
+            propertyName,
+            newValue,
+            seedLocalId,
+            versionLocalId,
+            modelName: itemModelName,
+            schemaUid,
+        });
+        sendBack({
+            type: 'updateContext',
+            propertyValue: newValue,
+        });
+        return true;
+    });
+    _analyzeInput().then((isDone) => {
+        if (isDone) {
+            sendBack({ type: 'saveValueToDbSuccess' });
+        }
+    });
+});
+
+// import { updateMachineContext } from '@/browser/helpers'
+const propertyMachine = setup({
+    types: {
+        context: {},
+        input: {},
+    },
+    // actions: {
+    //   updateContext: updateMachineContext,
+    // },
+    actors: {
+        waitForDb: waitForDb$1,
+        hydrateFromDb,
+        initialize: initialize$3,
+        resolveRelatedValue,
+        resolveRemoteStorage,
+        analyzeInput,
+        saveImageSrc,
+        saveRelation,
+        saveItemStorage,
+    },
+}).createMachine({
+    id: 'itemProperty',
+    initial: 'waitingForDb',
+    context: ({ input }) => input,
+    on: {
+        updatePropertyValue: {
+            target: '.resolvingRelatedValue',
+            guard: ({ context }) => !context.isDbReady,
+            actions: assign(({ event }) => {
+                return {
+                    propertyValue: event.propertyValue,
+                };
+            }),
+        },
+        updateRenderValue: {
+            actions: assign(({ event, context }) => {
+                return {
+                    renderValue: event.renderValue,
+                };
+            }),
+        },
+        save: {
+            actions: assign({
+                isSaving: true,
+            }),
+            target: '.saving',
+        },
+        updateContext: {
+            actions: assign(({ context, event }) => {
+                const newContext = Object.assign({}, context);
+                for (let i = 0; i < Object.keys(event).length; i++) {
+                    const key = Object.keys(event)[i];
+                    if (key === 'type') {
+                        continue;
+                    }
+                    newContext[key] = event[key];
+                }
+                return newContext;
+            }),
+        },
+    },
+    states: {
+        idle: {},
+        waitingForDb: {
+            on: {
+                waitForDbSuccess: {
+                    target: 'hydratingFromDb',
+                    actions: assign({
+                        isDbReady: true,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'waitForDb',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        hydratingFromDb: {
+            on: {
+                hydrateFromDbSuccess: 'initializing',
+            },
+            invoke: {
+                src: 'hydrateFromDb',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        initializing: {
+            on: {
+                initializeSuccess: 'idle',
+                isRelatedProperty: {
+                    target: 'resolvingRelatedValue',
+                },
+                hasRemoteBackup: {
+                    target: 'resolvingRemoteStorage',
+                },
+            },
+            invoke: {
+                src: 'initialize',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
+        resolvingRelatedValue: {
+            on: {
+                resolvingRelatedValueSuccess: {
+                    target: 'idle',
+                    actions: assign({
+                        resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
+                        resolvedValue: ({ event }) => event.resolvedValue,
+                    }),
+                },
+                resolvingRelatedValueDone: {
+                    target: 'idle',
+                },
+            },
+            invoke: {
+                src: 'resolveRelatedValue',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        resolvingRemoteStorage: {
+            on: {
+                resolveRemoteStorageSuccess: {
+                    target: 'idle',
+                },
+            },
+            invoke: {
+                src: 'resolveRemoteStorage',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        saving: {
+            initial: 'analyzingInput',
+            states: {
+                analyzingInput: {
+                    on: {
+                        saveValueToDbSuccess: {
+                            target: 'doneSaving',
+                        },
+                        saveImageSrc: 'savingImageSrc',
+                        saveRelation: 'savingRelation',
+                        saveItemStorage: 'savingItemStorage',
+                    },
+                    invoke: {
+                        src: 'analyzeInput',
+                        input: ({ context, event }) => ({ context, event }),
+                    },
+                },
+                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',
+                },
+            },
+            onDone: {
+                target: 'idle',
+                actions: assign(({ context }) => {
+                    return {
+                        isSaving: false,
+                    };
+                }),
+            },
+        },
+    },
+    // conflict: {
+    //   on: {
+    //     resolveConflict: {
+    //       target: 'saving',
+    //       actions: assign({
+    //         data: ({ context, event }) => event.output,
+    //       }),
+    //     },
+    //   },
+    // },
+});
+
+const TPropertyDataType = Type.Union([
+    Type.Literal('Text'),
+    Type.Literal('Number'),
+    Type.Literal('List'),
+    Type.Literal('Relation'),
+    Type.Literal('ImageSrc'),
+    Type.Literal('FileSrc'),
+    Type.Literal('Json'),
+    Type.Literal('Blob'),
+]);
+const TStorageType = Type.Union([
+    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
+    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
+]);
+const TProperty = Type.Object({
+    id: Type.Optional(Type.Number()),
+    name: Type.Optional(Type.String()),
+    dataType: TPropertyDataType,
+    ref: Type.Optional(Type.String()),
+    modelId: Type.Optional(Type.Number()),
+    refModelId: Type.Optional(Type.Number()),
+    refValueType: Type.Optional(TPropertyDataType),
+    storageType: Type.Optional(TStorageType),
+    localStorageDir: Type.Optional(Type.String()),
+    filenameSuffix: Type.Optional(Type.String()),
+});
+const TPropertyConstructor = Type.Function([
+    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
+    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
+    Type.Optional(Type.String()),
+], TProperty);
+Type.Record(TPropertyDataType, TPropertyConstructor);
+const Property = {
+    Text: (storageType, localStorageDir, filenameSuffix) => ({
+        dataType: 'Text',
+        storageType,
+        localStorageDir,
+        filenameSuffix,
+        TObject: Type.String(),
+    }),
+    Json: () => ({ dataType: 'Json' }),
+    Blob: () => ({ dataType: 'Blob' }),
+    Number: () => ({ dataType: 'Number' }),
+    List: (ref, refValueType) => ({
+        dataType: 'List',
+        ref,
+        refValueType,
+    }),
+    Relation: (ref, refValueType) => ({
+        dataType: 'Relation',
+        ref,
+        refValueType,
+    }),
+    ImageSrc: () => ({ dataType: 'ImageSrc' }),
+};
+const PropertyMetadataKey = Symbol('property');
+const PropertyConstructor = (propertyType) => {
+    return function (parentClassPrototype, propertyKey) {
+        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
+        existingProperties.push({ propertyKey, propertyType });
+        // console.log('existingProperties', existingProperties)
+        // console.log('propertyKey', propertyKey)
+        // console.log('propertyType', propertyType)
+        // console.log('PropertyMetadataKey', PropertyMetadataKey)
+        // console.log('typeof target', typeof target)
+        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
+        // console.log(
+        //   `After adding ${propertyKey}:`,
+        //   Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype),
+        // )
+    };
+};
+const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
+const Json = () => PropertyConstructor(Property.Json());
+const ImageSrc = () => PropertyConstructor(Property.ImageSrc());
+const Relation = (ref, refValueType) => PropertyConstructor(Property.Relation(ref, refValueType)); // Adjust for actual relation type
+const List = (ref, reValueType) => PropertyConstructor(Property.List(ref, reValueType)); // Adjust for actual list type
+
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 const TModelClass = Type.Object({
@@ -6956,4 +7370,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-DcXK4ERW.js.map
+//# sourceMappingURL=index-D4my8yy8.js.map