@seedprotocol/sdk 0.1.107 → 0.1.109

package/dist/{index-Dg23uBJg.js → index-vtm826YJ.js}

@@ -1,4 +1,4 @@
-import { b as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_DATA_TYPES, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, e as defaultAttestationData } from './constants-qIJt7998.js';
+import { b as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_DATA_TYPES, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, e as defaultAttestationData } from './constants-CEnkzyny.js';
 import path, { basename } from 'path';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
@@ -26,7 +26,7 @@ import { BehaviorSubject } from 'rxjs';
 import { drizzle } from 'drizzle-orm/sqlite-proxy';
 import { WebAccess } from '@zenfs/dom';
 import Arweave from 'arweave';
-import { ZERO_BYTES32, SchemaEncoder, ZERO_ADDRESS } from '@ethereum-attestation-service/eas-sdk';
+import { ZERO_BYTES32, SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
 
 const isNode = () => {
     return (typeof process !== 'undefined' &&
@@ -214,7 +214,7 @@ const waitForDb$1 = fromCallback(({ sendBack }) => {
     });
 });
 
-const logger$o = debug('app:shared:helpers');
+const logger$p = debug('app:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
     return customAlphabet(alphanumeric, 10)();
@@ -279,7 +279,7 @@ const convertTxIdToImageSrc = (txId) => __awaiter(void 0, void 0, void 0, functi
     const imageFilePath = `/files/images/${txId}`;
     const fileExists = yield fs.promises.exists(imageFilePath);
     if (!fileExists) {
-        logger$o(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$p(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
     const uint = yield fs.promises.readFile(imageFilePath);
@@ -744,7 +744,7 @@ const getPropertyData$1 = (propertyName, seedLocalId, seedUid) => __awaiter(void
         return;
     }
     const row = rows[0];
-    return Object.assign(Object.assign({}, row), { itemModelName: startCase(row.modelType) });
+    return Object.assign(Object.assign({}, row), { modelName: startCase(row.modelType) });
 });
 const seedUidToStorageTransactionId = new Map();
 const getStorageTransactionIdForSeedUid = (seedUid) => __awaiter(void 0, void 0, void 0, function* () {
@@ -826,18 +826,18 @@ const getExistingItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ see
 });
 
 var _a$2;
-const logger$n = debug('app:property:class');
+const logger$o = debug('app:property:class');
 const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
     // }
-    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
+    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, modelName, propertyName, storageTransactionId, schemaUid, }) {
         this._isRelation = false;
         this._isList = false;
         this[_a$2] = true;
-        const ModelClass = getModel(itemModelName);
+        const ModelClass = getModel(modelName);
         if (!ModelClass) {
-            throw new Error(`Model ${itemModelName} not found`);
+            throw new Error(`Model ${modelName} not found`);
         }
         if (!propertyName) {
             throw new Error(`Property name not provided`);
@@ -849,7 +849,7 @@ class ItemProperty {
             seedUid,
             versionLocalId,
             versionUid,
-            itemModelName,
+            modelName: modelName,
             storageTransactionId,
             propertyRecordSchema: ModelClass.schema[propertyName],
             schemaUid,
@@ -876,7 +876,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$n('List property value is not JSON', e);
+                            logger$o('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -898,6 +898,15 @@ class ItemProperty {
                 return;
             }
             const { context } = snapshot;
+            // if (
+            //   context.propertyName &&
+            //   context.propertyName.includes('featureImage')
+            // ) {
+            //   console.log(
+            //     `${context.localId} context for ${snapshot.value}`,
+            //     context,
+            //   )
+            // }
             if (context.seedLocalId) {
                 const cacheKey = ItemProperty.cacheKey(context.seedLocalId, context.propertyName);
                 if (!ItemProperty.instanceCache.has(cacheKey)) {
@@ -950,16 +959,16 @@ class ItemProperty {
             if (skipTransform && !this._alias) ;
             this._subject.next(renderValue);
             if (context.seedLocalId) {
-                eventEmitter.emit(`item.${itemModelName}.${context.seedLocalId}.update`);
+                eventEmitter.emit(`item.${modelName}.${context.seedLocalId}.update`);
             }
             if (context.seedUid) {
-                eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`);
+                eventEmitter.emit(`item.${modelName}.${context.seedUid}.update`);
             }
         }));
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$n(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$o(`[ItemProperty] [_updateResponseListener] [${this.modelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
@@ -1052,12 +1061,23 @@ class ItemProperty {
         }
         return this._getSnapshot().context.propertyName;
     }
-    get itemModelName() {
-        return this._getSnapshot().context.itemModelName;
+    get modelName() {
+        return this._getSnapshot().context.modelName;
     }
     get propertyDef() {
         return this._getSnapshot().context.propertyRecordSchema;
     }
+    get localStoragePath() {
+        if (this.propertyDef && this.propertyDef.localStorageDir) {
+            return `/files${this.propertyDef.localStorageDir}/${this._getSnapshot().context.refResolvedValue}`;
+        }
+        if (this._getSnapshot().context.localStorageDir) {
+            return `/files${this._getSnapshot().context.localStorageDir}/${this._getSnapshot().context.refResolvedValue}`;
+        }
+    }
+    get versionLocalId() {
+        return this._getSnapshot().context.versionLocalId;
+    }
     get status() {
         return this._getSnapshot().value;
     }
@@ -1106,7 +1126,7 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$n(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$o(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
@@ -1958,7 +1978,7 @@ const syncDbWithEasHandler = throttle((_) => __awaiter(void 0, void 0, void 0, f
     trailing: false,
 });
 
-const logger$m = debug('app:services:global:actors:initialize');
+const logger$n = debug('app:services:global:actors:initialize');
 const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints } = context;
     const { addresses } = event;
@@ -1979,7 +1999,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
         const _initInternal = () => __awaiter(void 0, void 0, void 0, function* () {
             return new Promise((resolve) => {
                 internalSubscription = internalService.subscribe((snapshot) => {
-                    logger$m('[sdk] [internal] snapshot', snapshot);
+                    logger$n('[sdk] [internal] snapshot', snapshot);
                     if (snapshot.value === 'ready') {
                         resolve();
                     }
@@ -2016,7 +2036,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
             yield fetchSchemaUids();
         });
         _initFileSystem().then(() => {
-            logger$m('[global/actors] File system initialized');
+            logger$n('[global/actors] File system initialized');
         });
         _initInternal()
             .then(() => {
@@ -2026,7 +2046,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
             return _initEas();
         })
             .then(() => {
-            logger$m('[global/actors] Internal initialized');
+            logger$n('[global/actors] Internal initialized');
             sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
             internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
         });
@@ -2040,7 +2060,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$l = debug('app:services:global:actors:getSchemaForModel');
+const logger$m = debug('app:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -2056,12 +2076,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$l('[service/actor] [getSchemaForModel] model:', model);
+    logger$m('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$k = debug('app:services:global:actors:addModelsToDb');
+const logger$l = debug('app:services:global:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models: models$1 } = context;
     const _addModelsToDb = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -2070,12 +2090,12 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-C1zm5m77.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-Brb7H5eC.js');
         const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
         for (const [modelName, _] of Object.entries(allModels)) {
-            logger$k('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$l('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = yield appDb
                 .select()
@@ -2085,7 +2105,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 yield appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$k('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$l('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = yield appDb
                     .select({
                     id: models.id,
@@ -2155,10 +2175,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$j = debug('app:services:db:actors:checkStatus');
+const logger$k = debug('app:services:db:actors:checkStatus');
 const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     const { dbName } = context;
-    logger$j('[db/actors] checkStatus context', context);
+    logger$k('[db/actors] checkStatus context', context);
     const pathToDir = `${BROWSER_FS_TOP_DIR}`;
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
@@ -2189,9 +2209,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$i = debug('app:services:db:actors:connectToDb');
+const logger$j = debug('app:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$i('[db/actors] connectToDb context', context);
+    logger$j('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     let isConnecting = false;
     let dbId;
@@ -2204,16 +2224,16 @@ const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
         const sqliteWasmClient = yield getSqliteWasmClient();
         //@ts-ignore
         response = yield sqliteWasmClient('config-get', {});
-        logger$i(response);
-        logger$i('Running SQLite3 version', response.result.version.libVersion);
+        logger$j(response);
+        logger$j('Running SQLite3 version', response.result.version.libVersion);
         //@ts-ignore
         response = yield sqliteWasmClient('open', {
             filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
         });
-        logger$i(response);
+        logger$j(response);
         dbId = response.dbId;
         // logger(`dbId: ${dbId}`)
-        logger$i('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
+        logger$j('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
     });
     const interval = setInterval(() => {
         // TODO: Add a timeout
@@ -2270,7 +2290,7 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$h = debug('app:services:db:actors:migrate');
+const logger$i = debug('app:services:db:actors:migrate');
 const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void 0, [dbId_1, params_1, sql_1, dbName_1, ...args_1], void 0, function* (dbId, params, sql, dbName, retries = 2) {
     const rowsToReturnRaw = [];
     const sqliteWasmClient = yield getSqliteWasmClient();
@@ -2336,7 +2356,7 @@ const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void
 });
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dbId, dbName } = context;
-    logger$h('[db/actors] migrate context', context);
+    logger$i('[db/actors] migrate context', context);
     const schemaGlobString = `${BROWSER_FS_TOP_DIR}/schema/*`;
     let journalExists = false;
     // const _initFs = async (): Promise<void> => {
@@ -2500,7 +2520,7 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$g = debug('app:services:db:machine');
+const logger$h = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -2521,7 +2541,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$g('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$h('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -2530,8 +2550,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$g('[db/machine] updateHasFiles event:', event);
-                    logger$g('[db/machine] updateHasFiles context:', context);
+                    logger$h('[db/machine] updateHasFiles event:', event);
+                    logger$h('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -2747,7 +2767,7 @@ const prepareDb = fromCallback(({ sendBack }) => {
     };
 });
 
-const logger$f = debug('app:services:internal:helpers');
+const logger$g = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -2823,7 +2843,7 @@ const downloadFile = (url, localFilePath) => __awaiter(void 0, void 0, void 0, f
         if (JSON.stringify(error).includes('File exists')) {
             yield fs.promises.readFile(localFilePath, 'utf-8');
         }
-        logger$f(`[Error] Failed to download file from ${url}:`, error);
+        logger$g(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 });
@@ -2861,7 +2881,7 @@ const syncDbFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ filePat
     const fileList = yield fetchDirectory(filePaths);
     yield fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
     yield confirmFilesExist(fileList);
-    logger$f('[syncDbFiles] Files synced!');
+    logger$g('[syncDbFiles] Files synced!');
 });
 
 const uploadBinaryData = fromCallback(({ sendBack, receive, input }) => { });
@@ -3100,7 +3120,7 @@ const saveAppState = (key, value) => __awaiter(void 0, void 0, void 0, function*
     });
 });
 
-const logger$e = debug('app:files:download');
+const logger$f = debug('app:files:download');
 const downloadAllFilesRequestHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ endpoints, eventId, }) {
     yield syncDbFiles(endpoints);
     eventEmitter.emit('fs.downloadAll.success', { eventId });
@@ -3184,7 +3204,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
         try {
             const res = yield fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
             if (res.status !== 200) {
-                logger$e(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$f(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 yield saveAppState('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -3224,7 +3244,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             //   string: true,
             // })
             if (!dataString) {
-                logger$e(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
+                logger$f(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
             let contentType = identifyString(dataString);
             if (contentType !== 'json' &&
@@ -3232,7 +3252,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 contentType !== 'html') {
                 const possibleImageType = getDataTypeFromString(dataString);
                 if (!possibleImageType) {
-                    logger$e(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    logger$f(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
                 }
                 contentType = possibleImageType;
@@ -3299,7 +3319,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             }
         }
         catch (error) {
-            logger$e(error);
+            logger$f(error);
         }
     }
 });
@@ -3345,14 +3365,14 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$d = debug('app:internal:actors:configureFs');
+const logger$e = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService } = context;
-    logger$d('[internal/actors] [configureFs] Configuring FS');
+    logger$e('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$d('[internal/actors] [configureFs] calling _configureFs');
-        logger$d('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$d('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$e('[internal/actors] [configureFs] calling _configureFs');
+        logger$e('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$e('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         yield waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -3381,7 +3401,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
         //     }
         //   }, 200)
         // })
-        logger$d('[internal/actors] [configureFs] fs configured!');
+        logger$e('[internal/actors] [configureFs] fs configured!');
     });
     // Some of our dependencies use fs sync functions, which don't work with
     // OPFS. ZenFS creates an async cache of all files so that the sync functions
@@ -3394,7 +3414,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$c = debug('app:services:internal:actors:saveConfig');
+const logger$d = debug('app:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     if (typeof window === 'undefined') {
         console.error('seedInitBrowser called from non-browser context');
@@ -3445,20 +3465,20 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                 },
                 setWhere: sql `key = 'addresses'`,
             });
-            logger$c('[sdk] [internal/actors] Should be done saving');
+            logger$d('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     });
     _saveConfig().then(() => {
-        logger$c('[sdk] [internal/actors] Successfully saved config');
+        logger$d('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$b = debug('app:services:internal:actors:loadAppDb');
+const logger$c = debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -3479,7 +3499,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$b('[sdk] [internal/actors] Successfully loaded app DB');
+        logger$c('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -3488,7 +3508,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$a = debug('app:services:internal:machine');
+const logger$b = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
@@ -3587,7 +3607,7 @@ const internalMachine = setup({
                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                     target: SAVING_CONFIG,
                     actions: () => {
-                        logger$a('[sdk] [internal/index] App DB loaded!');
+                        logger$b('[sdk] [internal/index] App DB loaded!');
                     },
                 },
             },
@@ -3613,7 +3633,7 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$a('[sdk] [internal/index] Ready!');
+                logger$b('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -3628,7 +3648,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$a('[sdk] [internal/index] Error!');
+                logger$b('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -3864,7 +3884,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$9 = debug('app:allItemsActors:fetchSeeds');
+const logger$a = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -3874,7 +3894,7 @@ const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const _fetchSeeds = () => __awaiter(void 0, void 0, void 0, function* () {
         const queryKey = [`getSeeds${modelName}`];
         const cachedResults = queryClient.getQueryData(queryKey);
-        logger$9(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$a(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
         const results = yield queryClient.fetchQuery({
             queryKey,
             queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return easClient.request(GET_SEEDS, queryVariables); }),
@@ -4319,13 +4339,13 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$8 = debug('app:services:publish:actors:upload');
+const logger$9 = 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$8('no item with localId', localId);
+            logger$9('no item with localId', localId);
             return false;
         }
         const editedProperties = yield item.getEditedProperties();
@@ -5159,7 +5179,7 @@ const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoc
     return rows[0];
 });
 
-const logger$7 = debug('app:db:queries:getItem');
+const logger$8 = 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');
@@ -5167,7 +5187,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$7('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$8('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -5194,7 +5214,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
         .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
         .groupBy(seeds.localId);
     if (!itemDataRows || itemDataRows.length === 0) {
-        logger$7('[db/queries] [getItemDataFromDb] no itemDataRows');
+        logger$8('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -5216,7 +5236,8 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
         }
         itemData[propertyName] = propertyValue;
     }
-    return itemData;
+    if (itemData)
+        return itemData;
 });
 const getItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, seedUid }) {
     const itemInitObj = yield getItemDataFromDb({
@@ -5235,6 +5256,55 @@ const getItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName,
     return Item.create(itemInitObj);
 });
 
+const getSegmentedItemProperties = (item) => {
+    const itemBasicProperties = [];
+    const itemRelationProperties = [];
+    const itemListProperties = [];
+    const itemUploadProperties = [];
+    const itemStorageProperties = [];
+    let itemStorageTransactionProperty;
+    for (const itemProperty of Object.values(item.properties)) {
+        if (!itemProperty.propertyDef) {
+            continue;
+        }
+        const isItemStorage = itemProperty.propertyDef.storageType &&
+            itemProperty.propertyDef.storageType === 'ItemStorage';
+        itemProperty.propertyDef.dataType === 'Relation' &&
+            itemProperty.propertyDef.refValueType === 'ImageSrc';
+        const isStorageTransaction = itemProperty.propertyName === 'storageTransactionId';
+        if (itemProperty.propertyDef.dataType === 'Relation') {
+            itemRelationProperties.push(itemProperty);
+            continue;
+        }
+        if (itemProperty.propertyDef.dataType === 'List') {
+            itemListProperties.push(itemProperty);
+            continue;
+        }
+        if (isItemStorage) {
+            itemStorageProperties.push(itemProperty);
+            continue;
+        }
+        if (isStorageTransaction) {
+            itemStorageTransactionProperty = { itemProperty, childProperties: [] };
+            continue;
+        }
+        itemBasicProperties.push(itemProperty);
+    }
+    if (itemStorageTransactionProperty && itemStorageProperties.length > 0) {
+        itemStorageTransactionProperty.childProperties = itemStorageProperties;
+    }
+    if (itemStorageTransactionProperty) {
+        itemUploadProperties.push(itemStorageTransactionProperty);
+    }
+    return {
+        itemBasicProperties,
+        itemRelationProperties,
+        itemListProperties,
+        itemUploadProperties,
+    };
+};
+
+debug('app:item:getPublishPayload');
 const getVersionUid = (item) => {
     let versionUid;
     if (item.latestVersionUid &&
@@ -5242,7 +5312,7 @@ const getVersionUid = (item) => {
         item.latestVersionUid !== 'undefined') {
         versionUid = item.latestVersionUid;
     }
-    return versionUid || ZERO_ADDRESS;
+    return versionUid || ZERO_BYTES32;
 };
 const getPropertyData = (itemProperty) => __awaiter(void 0, void 0, void 0, function* () {
     const easDataType = INTERNAL_DATA_TYPES[itemProperty.propertyDef.dataType].eas;
@@ -5268,37 +5338,6 @@ const getPropertyData = (itemProperty) => __awaiter(void 0, void 0, void 0, func
         propertyNameForSchema,
     };
 });
-const getSegmentedItemProperties = (item) => {
-    const itemBasicProperties = [];
-    const itemRelationProperties = [];
-    const itemListProperties = [];
-    const itemStorageProperties = [];
-    for (const itemProperty of Object.values(item.properties)) {
-        if (!itemProperty.propertyDef) {
-            continue;
-        }
-        if (itemProperty.propertyDef.dataType === 'Relation') {
-            itemRelationProperties.push(itemProperty);
-            continue;
-        }
-        if (itemProperty.propertyDef.dataType === 'List') {
-            itemListProperties.push(itemProperty);
-            continue;
-        }
-        if (itemProperty.propertyDef.storageType &&
-            itemProperty.propertyDef.storageType === 'ItemStorage') {
-            itemStorageProperties.push(itemProperty);
-            continue;
-        }
-        itemBasicProperties.push(itemProperty);
-    }
-    return {
-        itemBasicProperties,
-        itemRelationProperties,
-        itemListProperties,
-        itemStorageProperties,
-    };
-};
 const processBasicProperties = (itemBasicProperties, itemPublishData) => __awaiter(void 0, void 0, void 0, function* () {
     for (const basicProperty of itemBasicProperties) {
         const value = basicProperty.getService().getSnapshot().context.propertyValue;
@@ -5325,7 +5364,7 @@ const processBasicProperties = (itemBasicProperties, itemPublishData) => __await
     }
     return itemPublishData;
 });
-const processRelationProperty = (relationProperty, multiPublishPayload) => __awaiter(void 0, void 0, void 0, function* () {
+const processRelationProperty = (relationProperty, multiPublishPayload, uploadedTransactions) => __awaiter(void 0, void 0, void 0, function* () {
     const value = relationProperty.getService().getSnapshot()
         .context.propertyValue;
     if (!value || relationProperty.uid) {
@@ -5345,13 +5384,23 @@ const processRelationProperty = (relationProperty, multiPublishPayload) => __awa
         localId: relationProperty.localId,
         seedIsRevocable: true,
         versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
-        seedUid: seedUid || ZERO_ADDRESS,
+        seedUid: seedUid || ZERO_BYTES32,
         seedSchemaUid,
         versionUid,
         listOfAttestations: [],
         propertiesToUpdate: [],
     };
-    const { itemBasicProperties } = getSegmentedItemProperties(relatedItem);
+    const { itemBasicProperties, itemUploadProperties } = getSegmentedItemProperties(relatedItem);
+    if (itemUploadProperties.length === 1) {
+        const uploadProperty = itemUploadProperties[0];
+        const itemProperty = uploadProperty.itemProperty;
+        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === relatedItem.seedLocalId);
+        if (transactionData) {
+            itemProperty.value = transactionData.txId;
+            yield itemProperty.save();
+            itemBasicProperties.push(itemProperty);
+        }
+    }
     publishPayload = yield processBasicProperties(itemBasicProperties, publishPayload);
     multiPublishPayload.push(publishPayload);
     return multiPublishPayload;
@@ -5392,7 +5441,7 @@ const processListProperty = (listProperty, multiPublishPayload) => __awaiter(voi
             localId: relatedItem.seedLocalId,
             seedIsRevocable: true,
             versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
-            seedUid: seedUid || ZERO_ADDRESS,
+            seedUid: seedUid || ZERO_BYTES32,
             seedSchemaUid,
             versionUid,
             listOfAttestations: [],
@@ -5409,17 +5458,13 @@ const processListProperty = (listProperty, multiPublishPayload) => __awaiter(voi
     }
     return multiPublishPayload;
 });
-const getPublishPayload = (seedLocalId) => __awaiter(void 0, void 0, void 0, function* () {
-    const item = yield getItem({ seedLocalId });
-    if (!item) {
-        throw new Error('Item not found');
+const getPublishPayload = (item, uploadedTransactions) => __awaiter(void 0, void 0, void 0, function* () {
+    if (item.modelName === 'Post') {
+        item.authors = [
+            'Sr0bIx9Fwj',
+            '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+        ];
     }
-    // if (item.modelName === 'Post') {
-    //   item.authors = [
-    //     'Sr0bIx9Fwj',
-    //     '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
-    //   ]
-    // }
     let multiPublishPayload = [];
     // Each PublishPayload is generated from a Seed that needs publishing
     // First we need to determine all Seeds to publish
@@ -5430,15 +5475,25 @@ const getPublishPayload = (seedLocalId) => __awaiter(void 0, void 0, void 0, fun
         seedIsRevocable: true,
         seedSchemaUid: item.schemaUid,
         versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
-        versionUid: item.latestVersionUid || ZERO_BYTES32,
+        versionUid: getVersionUid(item),
         listOfAttestations: [],
         propertiesToUpdate: [],
     };
-    const { itemBasicProperties, itemRelationProperties, itemListProperties, itemStorageProperties, } = getSegmentedItemProperties(item);
+    const { itemBasicProperties, itemRelationProperties, itemListProperties, itemUploadProperties, } = getSegmentedItemProperties(item);
+    if (itemUploadProperties.length === 1) {
+        const uploadProperty = itemUploadProperties[0];
+        const itemProperty = uploadProperty.itemProperty;
+        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === item.seedLocalId);
+        if (transactionData) {
+            itemProperty.value = transactionData.txId;
+            yield itemProperty.save();
+            itemBasicProperties.push(itemProperty);
+        }
+    }
     itemPublishData = yield processBasicProperties(itemBasicProperties, itemPublishData);
     multiPublishPayload.push(itemPublishData);
     for (const relationProperty of itemRelationProperties) {
-        multiPublishPayload = yield processRelationProperty(relationProperty, multiPublishPayload);
+        multiPublishPayload = yield processRelationProperty(relationProperty, multiPublishPayload, uploadedTransactions);
     }
     for (const listProperty of itemListProperties) {
         multiPublishPayload = yield processListProperty(listProperty, multiPublishPayload);
@@ -5446,6 +5501,153 @@ const getPublishPayload = (seedLocalId) => __awaiter(void 0, void 0, void 0, fun
     return multiPublishPayload;
 });
 
+const logger$7 = debug('app:item:getPublishUploads');
+const getContentHash = (base64, uint) => __awaiter(void 0, void 0, void 0, function* () {
+    let data;
+    if (uint) {
+        data = uint;
+    }
+    // Hash the data with SHA-256
+    const hashBuffer = yield crypto.subtle.digest('SHA-256', data);
+    // Convert the ArrayBuffer to a hex string
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+});
+const prepareArweaveTransaction = (data, contentHash) => __awaiter(void 0, void 0, void 0, function* () {
+    const transactionData = {
+        data,
+        tags: [],
+    };
+    const tx = yield getArweave().createTransaction(transactionData);
+    if (contentHash) {
+        logger$7('contentHash', contentHash);
+        logger$7('adding content hash tag to tx.id:', tx.id);
+        tx.addTag('Content-SHA-256', contentHash);
+    }
+    return tx;
+});
+const processUploadProperty = (uploadProperty, uploads, relatedItemProperty) => __awaiter(void 0, void 0, void 0, function* () {
+    const itemProperty = uploadProperty.itemProperty;
+    const childUploads = [];
+    for (const childProperty of uploadProperty.childProperties) {
+        const filePath = childProperty.localStoragePath;
+        if (!filePath) {
+            throw new Error(`No localStoragePath found for ItemProperty ${childProperty.propertyName}`);
+        }
+        const exists = yield fs.promises.exists(filePath);
+        if (!exists) {
+            throw new Error(`File doesn't exist at ${filePath}`);
+        }
+        childUploads.push({
+            propertyName: childProperty.propertyName,
+            localStoragePath: filePath,
+        });
+    }
+    // const filePath = itemProperty.localStoragePath
+    //
+    // if (!filePath) {
+    //   throw new Error(
+    //     `No localStoragePath found for ItemProperty ${itemProperty.propertyName}`,
+    //   )
+    // }
+    //
+    // const exists = await fs.promises.exists(filePath)
+    // if (!exists) {
+    //   throw new Error(`File doesn't exist at ${filePath}`)
+    //
+    //   // const handle = await navigator.storage.getDirectory()
+    //   //
+    //   // await configureSingle({
+    //   //   backend: WebAccess,
+    //   //   handle,
+    //   // })
+    // }
+    //
+    // const mainFileContents = await fs.promises.readFile(filePath)
+    let fileContents;
+    let transaction;
+    if (!childUploads || childUploads.length === 0) {
+        if (relatedItemProperty && relatedItemProperty.localStoragePath) {
+            const filePath = relatedItemProperty.localStoragePath;
+            const exists = yield fs.promises.exists(filePath);
+            if (!exists) {
+                throw new Error(`File doesn't exist at ${filePath}`);
+                // const handle = await navigator.storage.getDirectory()
+                //
+                // await configureSingle({
+                //   backend: WebAccess,
+                //   handle,
+                // })
+            }
+            fileContents = yield fs.promises.readFile(filePath);
+        }
+        if (!fileContents) {
+            return uploads;
+        }
+    }
+    if (childUploads.length > 0) {
+        const separator = '===FILE_SEPARATOR===';
+        // let compositeFileContents = `${itemProperty.propertyName}${separator}${mainFileContents}`
+        let compositeFileContents = '';
+        for (const childUpload of childUploads) {
+            const childUploadContents = yield fs.promises.readFile(childUpload.localStoragePath);
+            compositeFileContents += `${separator}${childUpload.propertyName}${separator}${childUploadContents}`;
+        }
+        fileContents = Buffer.from(compositeFileContents);
+    }
+    if (!fileContents) {
+        throw new Error(`No file contents found for ${itemProperty.propertyName}`);
+    }
+    const uint8Array = new Uint8Array(fileContents.buffer, fileContents.byteOffset, fileContents.byteLength);
+    const contentHash = yield getContentHash(null, uint8Array);
+    transaction = yield prepareArweaveTransaction(fileContents, contentHash);
+    let itemPropertyLocalId = relatedItemProperty
+        ? relatedItemProperty.localId
+        : itemProperty.localId;
+    let itemPropertyName = relatedItemProperty
+        ? relatedItemProperty.propertyName
+        : itemProperty.propertyName;
+    uploads.push({
+        itemPropertyName,
+        itemPropertyLocalId,
+        seedLocalId: itemProperty.seedLocalId,
+        versionLocalId: itemProperty.versionLocalId,
+        transactionToSign: transaction,
+    });
+    return uploads;
+});
+const getPublishUploads = (item_1, ...args_1) => __awaiter(void 0, [item_1, ...args_1], void 0, function* (item, uploads = [], relatedItemProperty) {
+    if (item.modelName === 'Post') {
+        if (!item.authors) {
+            item.authors = [
+                'Sr0bIx9Fwj',
+                '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+            ];
+        }
+    }
+    const { itemUploadProperties, itemRelationProperties } = getSegmentedItemProperties(item);
+    for (const uploadProperty of itemUploadProperties) {
+        uploads = yield processUploadProperty(uploadProperty, uploads, relatedItemProperty);
+    }
+    for (const relationProperty of itemRelationProperties) {
+        const propertyValue = relationProperty.getService().getSnapshot()
+            .context.propertyValue;
+        if (!propertyValue || relationProperty.uid) {
+            continue;
+        }
+        const { localId: seedLocalId, uid: seedUid } = getCorrectId(propertyValue);
+        const relatedItem = yield Item.find({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            throw new Error(`No relatedItem found for ${relationProperty.propertyName}`);
+        }
+        uploads = yield getPublishUploads(relatedItem, uploads, relationProperty);
+    }
+    return uploads;
+});
+
 var _a$1;
 class Item {
     constructor(initialValues) {
@@ -5478,8 +5680,11 @@ class Item {
                 },
             });
         });
-        this.getPublishPayload = () => __awaiter(this, void 0, void 0, function* () {
-            return yield getPublishPayload(this.seedLocalId);
+        this.getPublishUploads = () => __awaiter(this, void 0, void 0, function* () {
+            return yield getPublishUploads(this);
+        });
+        this.getPublishPayload = (uploadedTransactions) => __awaiter(this, void 0, void 0, function* () {
+            return yield getPublishPayload(this, uploadedTransactions);
         });
         const { modelName, seedUid, schemaUid, seedLocalId, latestVersionLocalId, latestVersionUid, } = initialValues;
         const ModelClass = getModel(modelName);
@@ -5535,7 +5740,7 @@ class Item {
             seedUid,
             versionLocalId: latestVersionLocalId,
             versionUid: latestVersionUid,
-            itemModelName: modelName,
+            modelName: modelName,
         };
         if (ModelClass && ModelClass.schema) {
             const schema = ModelClass.schema;
@@ -5545,6 +5750,16 @@ class Item {
                 }
                 this._createPropertyInstance(Object.assign(Object.assign({}, itemPropertyBase), { propertyName, propertyValue: initialValues[propertyName] }));
                 definedKeys.push(propertyName);
+                if (propertyRecordSchema.dataType === 'Relation' &&
+                    !propertyName.endsWith('Id')) {
+                    definedKeys.push(`${propertyName}Id`);
+                }
+                if (propertyRecordSchema.dataType === 'List' &&
+                    !propertyName.endsWith('Ids')) {
+                    const singularPropertyName = pluralize.singular(propertyName);
+                    const propertyNameForSchema = `${singularPropertyName}${propertyRecordSchema.ref}Ids`;
+                    definedKeys.push(propertyNameForSchema);
+                }
             }
         }
         Object.keys(initialValues).forEach((key) => {
@@ -5582,9 +5797,7 @@ class Item {
                             type: 'updateContext',
                             propertyValue,
                         });
-                        // propertyInstance.getService().send({ type: 'reload' })
                     }
-                    // instance.getService().send({ type: 'reload' })
                     return instance;
                 }
                 if (!Item.instanceCache.has(seedId)) {
@@ -5672,20 +5885,23 @@ class Item {
             enumerable: true,
         });
     }
+    get serviceContext() {
+        return this._service.getSnapshot().context;
+    }
     get seedLocalId() {
-        return this._service.getSnapshot().context.seedLocalId;
+        return this.serviceContext.seedLocalId;
     }
     get seedUid() {
-        return this._service.getSnapshot().context.seedUid;
+        return this.serviceContext.seedUid;
     }
     get schemaUid() {
-        return this._service.getSnapshot().context.schemaUid;
+        return this.serviceContext.schemaUid;
     }
     get latestVersionUid() {
-        return this._service.getSnapshot().context.latestVersionUid;
+        return this.serviceContext.latestVersionUid;
     }
     get modelName() {
-        return this._service.getSnapshot().context.modelName;
+        return this.serviceContext.modelName;
     }
     get properties() {
         return this._propertiesSubject.value;
@@ -6235,7 +6451,7 @@ const client = {
             console.error('fs listeners not ready during init');
         }
         globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-C1zm5m77.js').then(({ models }) => {
+        import('./seed.schema.config-Brb7H5eC.js').then(({ models }) => {
             for (const [key, value] of Object.entries(models)) {
                 setModel(key, value);
             }
@@ -6442,7 +6658,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             });
             sendBack({
                 type: 'resolvingRelatedValueSuccess',
-                resolvedDisplayValue: contentUrl,
+                refResolvedDisplayValue: contentUrl,
             });
             return true;
         }
@@ -6465,8 +6681,8 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                 });
                 sendBack({
                     type: 'resolvingRelatedValueSuccess',
-                    resolvedDisplayValue: contentUrl,
-                    resolvedValue: storageTransactionId,
+                    refResolvedDisplayValue: contentUrl,
+                    refResolvedValue: storageTransactionId,
                 });
                 return true;
             }
@@ -6480,8 +6696,8 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             });
             sendBack({
                 type: 'resolvingRelatedValueSuccess',
-                resolvedDisplayValue: contentUrl,
-                resolvedValue: storageTransactionId,
+                refResolvedDisplayValue: contentUrl,
+                refResolvedValue: storageTransactionId,
             });
             return true;
         }
@@ -6502,7 +6718,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                     });
                     sendBack({
                         type: 'resolvingRelatedValueSuccess',
-                        resolvedDisplayValue: contentUrl,
+                        refResolvedDisplayValue: contentUrl,
                     });
                     return true;
                 }
@@ -6518,7 +6734,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                     });
                     sendBack({
                         type: 'resolvingRelatedValueSuccess',
-                        resolvedDisplayValue: contentUrl,
+                        refResolvedDisplayValue: contentUrl,
                     });
                     return true;
                 }
@@ -6548,7 +6764,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
                         });
                         sendBack({
                             type: 'resolvingRelatedValueSuccess',
-                            resolvedDisplayValue: contentUrl,
+                            refResolvedDisplayValue: contentUrl,
                         });
                         return true;
                     }
@@ -6641,13 +6857,13 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
 //         )
 //       }
 //
-//       const resolvedDisplayValue = storageIdQuery.rows[0][2]
+//       const refResolvedDisplayValue = storageIdQuery.rows[0][2]
 //       let resolvedValue = storageIdQuery.rows[0][3]
 //
-//       if (resolvedDisplayValue && resolvedValue) {
+//       if (refResolvedDisplayValue && resolvedValue) {
 //         sendBack({
 //           type: 'resolvingRelatedValueSuccess',
-//           resolvedDisplayValue,
+//           refResolvedDisplayValue,
 //           resolvedValue,
 //         })
 //         return
@@ -6679,7 +6895,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
 //
 //       sendBack({
 //         type: 'resolvingRelatedValueSuccess',
-//         resolvedDisplayValue: contentUrl,
+//         refResolvedDisplayValue: contentUrl,
 //         resolvedValue: storageId,
 //       })
 //     }
@@ -6738,7 +6954,7 @@ const updateMetadata = (metadataValues) => __awaiter(void 0, void 0, void 0, fun
 
 const logger$1 = debug('app:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, itemModelName, } = context;
+    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, modelName, } = context;
     let propertyName = propertyNameRaw;
     if (propertyRecordSchema &&
         propertyRecordSchema.ref &&
@@ -6902,18 +7118,18 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             schemaUid: schemaUidFromDb,
             refValueType,
             localStorageDir,
-            resolvedValue: refResolvedValue,
-            resolvedDisplayValue: refResolvedDisplayValue,
+            refResolvedValue,
+            refResolvedDisplayValue,
             renderValue: refResolvedDisplayValue,
             populatedFromDb: true,
         });
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = yield import('./index-BmzLHFCL.js');
+            const { Item } = yield import('./index-vHcSfvyu.js');
             const item = yield Item.find({
                 seedLocalId,
-                modelName: itemModelName,
+                modelName,
             });
             if (item) {
                 const filePath = `/files/${localStorageDir}/${refResolvedValue}`;
@@ -7103,7 +7319,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
 });
 
 const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, seedLocalId, versionLocalId, versionUid, propertyValue: existingValue, propertyRecordSchema, itemModelName, } = context;
+    const { localId, propertyName: propertyNameRaw, seedLocalId, versionLocalId, versionUid, propertyValue: existingValue, propertyRecordSchema, modelName, } = context;
     let { schemaUid } = context;
     let newValue;
     if (event) {
@@ -7164,7 +7380,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             seedLocalId,
             versionLocalId,
             versionUid,
-            modelName: itemModelName,
+            modelName,
             schemaUid,
         });
         sendBack({
@@ -7204,7 +7420,7 @@ const fetchImage = (url) => __awaiter(void 0, void 0, void 0, function* () {
 });
 let imageSchemaUid;
 const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, } = context;
+    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, modelName, seedLocalId, seedUid, versionLocalId, versionUid, } = context;
     let { schemaUid } = context;
     let newValue;
     if (event) {
@@ -7283,7 +7499,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 seedUid,
                 versionLocalId,
                 versionUid,
-                modelName: itemModelName,
+                modelName,
                 schemaUid,
                 refSeedType: 'image',
                 refModelUid: imageSchemaUid,
@@ -7301,7 +7517,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 newValue: newImageSeedLocalId,
                 seedLocalId,
                 versionLocalId,
-                modelName: itemModelName,
+                modelName,
                 schemaUid,
                 refSeedType: 'image',
                 refResolvedDisplayValue,
@@ -7318,8 +7534,8 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
             refSeedType: 'image',
             refSchemaUid: imageSchemaUid,
             renderValue: refResolvedDisplayValue,
-            resolvedDisplayValue: refResolvedDisplayValue,
-            resolvedValue: fileName,
+            refResolvedDisplayValue: refResolvedDisplayValue,
+            refResolvedValue: fileName,
             localStorageDir: '/images',
             easDataType: 'bytes32',
         });
@@ -7425,7 +7641,7 @@ const getItemPropertyData = (props) => __awaiter(void 0, void 0, void 0, functio
 });
 
 const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, seedLocalId, seedUid, propertyName, propertyRecordSchema, itemModelName, propertyValue: existingValue, } = context;
+    const { localId, seedLocalId, seedUid, propertyName, propertyRecordSchema, modelName, propertyValue: existingValue, } = context;
     if (!propertyRecordSchema) {
         throw new Error('Missing propertyRecordSchema');
     }
@@ -7468,7 +7684,7 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
                 if (!propertyData) {
                     const propertyDataRows = yield createMetadata({
                         propertyName,
-                        modelType: itemModelName.toLowerCase(),
+                        modelType: modelName.toLowerCase(),
                         seedLocalId,
                         seedUid,
                         versionLocalId: itemData.latestVersionLocalId,
@@ -7606,8 +7822,8 @@ const propertyMachine = setup({
                 resolvingRelatedValueSuccess: {
                     target: 'idle',
                     actions: assign({
-                        resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
-                        resolvedValue: ({ event }) => event.resolvedValue,
+                        refResolvedDisplayValue: ({ event }) => event.refResolvedDisplayValue,
+                        resolvedValue: ({ event }) => event.refResolvedValue,
                     }),
                 },
                 resolvingRelatedValueDone: {
@@ -7852,4 +8068,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_SCHEMA_BY_NAME as a, GET_SEEDS as b, GET_SEED_IDS as c, GET_STORAGE_TRANSACTION_ID as d, GET_VERSIONS as e, GET_PROPERTIES as f, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as g, itemMachineAll as h, itemMachineSingle as i, ImageSrc as j, ItemProperty as k, useItem as l, useItemProperties as m, useCreateItem as n, useItemProperty as o, useDeleteItem as p, useGlobalServiceStatus as q, useServices as r, getGlobalService as s, client as t, useItems as u, getCorrectId as v, withSeed as w };
-//# sourceMappingURL=index-Dg23uBJg.js.map
+//# sourceMappingURL=index-vtm826YJ.js.map