@seedprotocol/sdk 0.1.105 → 0.1.106

package/dist/{index--nvTinP_.js → index-CvfKxmFw.js}

@@ -1,15 +1,14 @@
-import { b as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_DATA_TYPES, e as defaultAttestationData, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA } from './constants-rmQ8zg8_.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-qIJt7998.js';
 import path, { basename } from 'path';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, createActor, waitFor, setup, assign, raise } from 'xstate';
-import { sql, relations, or, eq, and, max, count, isNotNull, isNull, gt, inArray, like, getTableColumns } from 'drizzle-orm';
+import { sql, relations, count, max, eq, or, isNotNull, isNull, and, gt, inArray, like, getTableColumns } from 'drizzle-orm';
 import { fs, configureSingle } from '@zenfs/core';
 import 'dayjs';
 import { customAlphabet } from 'nanoid';
 import * as nanoIdDictionary from 'nanoid-dictionary';
 import debug from 'debug';
-import { startCase, throttle, camelCase, orderBy } from 'lodash-es';
 import { sqliteTable, text, int, blob, check, unique } from 'drizzle-orm/sqlite-core';
 import { useState, useEffect, useRef, useCallback } from 'react';
 import { QueryClient } from '@tanstack/react-query';
@@ -19,6 +18,7 @@ import { persistQueryClient } from '@tanstack/react-query-persist-client';
 import { useImmer } from 'use-immer';
 import { useSelector } from '@xstate/react';
 import EventEmitter from 'eventemitter3';
+import { startCase, throttle, camelCase, orderBy } from 'lodash-es';
 import { immerable, produce, enableMapSet } from 'immer';
 import pluralize from 'pluralize';
 import { createBrowserInspector } from '@statelyai/inspect';
@@ -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 { SchemaEncoder, ZERO_ADDRESS } from '@ethereum-attestation-service/eas-sdk';
+import { ZERO_ADDRESS, SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
 
 const isNode = () => {
     return (typeof process !== 'undefined' &&
@@ -87,6 +87,63 @@ const withSeed$1 = (config, webpack, isServer) => {
     return config;
 };
 
+const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) => {
+    const { propertyInstances } = context;
+    if (!propertyInstances) {
+        throw new Error(`propertyInstances not found for ${context.seedLocalId}`);
+    }
+    if (!propertyInstances.has('storageTransactionId')) {
+        return;
+    }
+    const storageTransactionId = propertyInstances.get('storageTransactionId');
+    const _resolveRemoteStorage = () => __awaiter(void 0, void 0, void 0, function* () {
+        const path = yield import('path-browserify');
+        const { fs } = yield import('@zenfs/core');
+        const filesDirExists = yield fs.promises.exists('/files');
+        if (!filesDirExists) {
+            yield fs.promises.mkdir('/files');
+        }
+        const htmlDir = path.join('/files', 'html');
+        const htmlExists = yield fs.promises.exists(htmlDir);
+        if (htmlExists) {
+            const htmlFiles = yield fs.promises.readdir(htmlDir);
+            const matchingHtmlFile = htmlFiles.find((file) => file === `${storageTransactionId}.html`);
+            if (matchingHtmlFile) {
+                const htmlString = yield fs.promises.readFile(path.join(htmlDir, matchingHtmlFile), 'utf8');
+                sendBack({
+                    type: 'updateValue',
+                    propertyName: 'html',
+                    propertyValue: htmlString,
+                });
+            }
+        }
+        if (!htmlExists) {
+            yield fs.promises.mkdir(htmlDir);
+        }
+        const jsonDir = path.join('/files', 'json');
+        const jsonExists = yield fs.promises.exists(jsonDir);
+        if (jsonExists) {
+            const jsonFiles = yield fs.promises.readdir(jsonDir);
+            const matchingJsonFile = jsonFiles.find((file) => file === `${storageTransactionId}.json`);
+            if (matchingJsonFile) {
+                const jsonString = yield fs.promises.readFile(path.join(jsonDir, matchingJsonFile), 'utf8');
+                sendBack({
+                    type: 'updateValue',
+                    propertyName: 'json',
+                    propertyValue: jsonString,
+                });
+            }
+        }
+        if (!jsonExists) {
+            yield fs.promises.mkdir(jsonDir);
+        }
+    });
+    _resolveRemoteStorage().then(() => {
+        sendBack({ type: 'resolveRemoteStorageSuccess' });
+        return;
+    });
+});
+
 let sqlite3InitModule;
 let sqliteWasmClient;
 let isPreparing = false;
@@ -157,55 +214,6 @@ const waitForDb$1 = fromCallback(({ sendBack }) => {
     });
 });
 
-const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
-    const { isRelation, propertyName, storageTransactionId } = context;
-    if (isRelation) {
-        sendBack({ type: 'isRelatedProperty' });
-        sendBack({ type: 'initializeSuccess' });
-        return;
-    }
-    if (!isRelation) {
-        if ((propertyName !== 'html' && propertyName !== 'json') ||
-            !storageTransactionId) {
-            sendBack({ type: 'initializeSuccess' });
-            return;
-        }
-        const _getContentsFromFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
-            if (propertyName === 'html') {
-                const htmlFilePath = `/files/html/${storageTransactionId}.html`;
-                const exists = yield fs.promises.exists(htmlFilePath);
-                if (!exists) {
-                    return;
-                }
-                const renderValue = yield fs.promises
-                    .readFile(`/files/html/${storageTransactionId}.html`, 'utf8')
-                    .catch((error) => {
-                    console.warn('Error reading html file', error);
-                });
-                sendBack({ type: 'updateContext', renderValue });
-                return;
-            }
-            if (propertyName === 'json') {
-                const jsonFilePath = `/files/json/${storageTransactionId}.json`;
-                const exists = yield fs.promises.exists(jsonFilePath);
-                if (!exists) {
-                    return;
-                }
-                const renderValue = yield fs.promises
-                    .readFile(`/files/json/${storageTransactionId}.json`, 'utf8')
-                    .catch((error) => {
-                    console.warn('Error reading json file', error);
-                });
-                sendBack({ type: 'updateContext', renderValue });
-                return;
-            }
-        });
-        _getContentsFromFileSystem().then(() => {
-            sendBack({ type: 'initializeSuccess' });
-        });
-    }
-});
-
 const logger$o = debug('app:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
@@ -278,6 +286,7 @@ const convertTxIdToImageSrc = (txId) => __awaiter(void 0, void 0, void 0, functi
     const imageBlob = new Blob([uint]);
     return URL.createObjectURL(imageBlob);
 });
+const capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
 const parseEasRelationPropertyName = (easPropertyName) => {
     // Split the input string on the first underscore
     const [singularProperty, modelName, idSegment] = easPropertyName.split('_');
@@ -416,777 +425,71 @@ relations(propertyUids, ({ one }) => ({
     property: one(properties),
 }));
 
-const getPropertyData = (propertyName, seedLocalId, seedUid) => __awaiter(void 0, void 0, void 0, function* () {
+const getVersionData$1 = () => {
     const appDb = getAppDb();
-    const whereClauses = [
-        or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, propertyName + 'Id'), eq(metadata.propertyName, propertyName + 'Ids')),
-    ];
-    if (seedLocalId) {
-        whereClauses.push(eq(metadata.seedLocalId, seedLocalId));
-    }
-    if (seedUid) {
-        whereClauses.push(eq(metadata.seedUid, seedUid));
+    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()));
     }
-    const rows = (yield appDb
-        .select()
-        .from(metadata)
-        .where(and(...whereClauses))
-        .orderBy(sql.raw(`COALESCE(attestation_created_at, created_at) DESC`)));
-    if (!rows || rows.length === 0) {
-        return;
+    if (deleted) {
+        conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
     }
-    const row = rows[0];
-    return Object.assign(Object.assign({}, row), { itemModelName: startCase(row.modelType) });
-});
-const seedUidToStorageTransactionId = new Map();
-const getStorageTransactionIdForSeedUid = (seedUid) => __awaiter(void 0, void 0, void 0, function* () {
-    if (seedUidToStorageTransactionId.has(seedUid)) {
-        return seedUidToStorageTransactionId.get(seedUid);
+    if (!deleted) {
+        conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
     }
-    const appDb = getAppDb();
-    const results = (yield appDb
+    const versionData = getVersionData$1();
+    let query = appDb
+        .with(versionData)
         .select({
-        storageTransactionId: metadata.propertyValue,
+        seedLocalId: seeds.localId,
+        seedUid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        modelName: sql `${modelName}`,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        versionsCount: versionData.versionsCount,
+        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
+        latestVersionUid: versionData.latestVersionUid,
+        latestVersionLocalId: versionData.latestVersionLocalId,
+        createdAt: seeds.createdAt,
     })
-        .from(metadata)
-        .where(and(eq(metadata.seedUid, seedUid), eq(metadata.propertyName, 'storageTransactionId'))));
-    if (!results || results.length === 0) {
-        return;
-    }
-    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
-    return results[0].storageTransactionId;
+        .from(seeds)
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+        .where(and(gt(versionData.versionsCount, 0), ...conditions))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+        .groupBy(seeds.localId);
+    const itemsData = (yield query);
+    return itemsData;
 });
-const getRelationValueData = (propertyValue) => __awaiter(void 0, void 0, void 0, function* () {
+
+const createVersion = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, seedType, uid, }) {
     const appDb = getAppDb();
-    const rows = (yield appDb
-        .select({
-        propertyValue: metadata.propertyValue,
-        attestationCreatedAt: max(metadata.attestationCreatedAt),
-        refResolvedDisplayValue: metadata.refResolvedDisplayValue,
-        refResolvedValue: metadata.refResolvedValue,
-        refSeedType: metadata.refSeedType,
-        easDataType: metadata.easDataType,
-    })
-        .from(metadata)
-        .where(eq(metadata.propertyValue, propertyValue)));
-    if (!rows || rows.length === 0) {
-        return;
-    }
-    return rows[0];
-});
-const getExistingItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, }) {
-    const existingItemStatement = `SELECT local_id, uid, created_at
-                                 FROM seeds
-                                 WHERE (uid IS NOT NULL
-                                     AND uid != ''
-                                     AND uid != 'undefined'
-                                     AND uid != 'null'
-                                     AND uid != 'false'
-                                     AND uid != '0'
-                                     AND uid != 0
-                                     AND uid = '${seedUid}'
-                                     )
-                                    OR (
-                                     local_id IS NOT NULL
-                                         AND local_id != ''
-                                         AND local_id != 'undefined'
-                                         AND local_id != 'null'
-                                         AND local_id != 'false'
-                                         AND local_id != '0'
-                                         AND local_id != 0
-                                         AND local_id = '${seedLocalId}'
-                                     );
-  `;
-    const { rows } = yield runQueryForStatement(existingItemStatement);
-    let existingItem;
-    if (rows && rows.length > 0) {
-        // We know the zero index is versionLocalId because we specifically asked for it first
-        // in the SELECT statement above. Same with the rest of the indexes.
-        let matchingRow = rows.find((row) => row[1] === seedUid);
-        if (!matchingRow) {
-            matchingRow = rows.find((row) => row[0] === seedLocalId);
-        }
-        if (matchingRow) {
-            existingItem = {
-                seedLocalId: matchingRow[0],
-                seedUid: matchingRow[1],
-                createdAt: matchingRow[2],
-            };
-        }
-    }
-    return existingItem;
-});
-
-const logger$n = debug('app:property:actors:resolveRelatedValue');
-const storageTransactionIdToContentUrl = new Map();
-const refResolvedValueToContentUrl = new Map();
-const seedUidToContentUrl = new Map();
-const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
-    const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
-    const _resolveRelatedValue = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!propertyValue || !isRelation || populatedFromDb) {
-            return;
-        }
-        let parsedValue;
-        try {
-            parsedValue = JSON.parse(propertyValue);
-        }
-        catch (error) {
-            logger$n(`${propertyName} value is not a JSON string.`);
-        }
-        if (!parsedValue && seedUidToContentUrl.has(propertyValue)) {
-            const contentUrl = seedUidToContentUrl.get(propertyValue);
-            sendBack({
-                type: 'updateContext',
-                renderValue: contentUrl,
-            });
-            sendBack({
-                type: 'resolvingRelatedValueSuccess',
-                resolvedDisplayValue: contentUrl,
-            });
-            return true;
-        }
-        if (Array.isArray(propertyValue)) {
-            // TODO: Handle array of seedUids
-            logger$n(`${propertyName} value is an array of seedUids`);
-            return;
-        }
-        if (Array.isArray(parsedValue)) {
-            logger$n(`${propertyName} value is a stringified array of seedUids`);
-            return;
-        }
-        const storageTransactionId = yield getStorageTransactionIdForSeedUid(propertyValue);
-        if (storageTransactionId) {
-            if (storageTransactionIdToContentUrl.has(storageTransactionId)) {
-                const contentUrl = storageTransactionIdToContentUrl.get(storageTransactionId);
-                sendBack({
-                    type: 'updateContext',
-                    renderValue: contentUrl,
-                });
-                sendBack({
-                    type: 'resolvingRelatedValueSuccess',
-                    resolvedDisplayValue: contentUrl,
-                    resolvedValue: storageTransactionId,
-                });
-                return true;
-            }
-            const contentUrl = yield convertTxIdToImageSrc(storageTransactionId);
-            if (contentUrl) {
-                seedUidToContentUrl.set(propertyValue, contentUrl);
-            }
-            sendBack({
-                type: 'updateContext',
-                renderValue: contentUrl,
-            });
-            sendBack({
-                type: 'resolvingRelatedValueSuccess',
-                resolvedDisplayValue: contentUrl,
-                resolvedValue: storageTransactionId,
-            });
-            return true;
-        }
-        const relationValueData = yield getRelationValueData(propertyValue);
-        if (relationValueData) {
-            const { refResolvedValue } = relationValueData;
-            const propertyValueFromDb = relationValueData.propertyValue;
-            // This handles a local-only relation value and resolves from the filesystem
-            if (refResolvedValue &&
-                propertyRecordSchema.dataType === 'Relation' &&
-                propertyValueFromDb.length === 10 &&
-                propertyRecordSchema.ref) {
-                if (refResolvedValueToContentUrl.has(refResolvedValue)) {
-                    const contentUrl = refResolvedValueToContentUrl.get(refResolvedValue);
-                    sendBack({
-                        type: 'updateContext',
-                        renderValue: contentUrl,
-                    });
-                    sendBack({
-                        type: 'resolvingRelatedValueSuccess',
-                        resolvedDisplayValue: contentUrl,
-                    });
-                    return true;
-                }
-                const fileExists = yield fs.promises.exists('/files/images/' + refResolvedValue);
-                if (fileExists) {
-                    const fileContents = yield fs.promises.readFile('/files/images/' + refResolvedValue);
-                    const fileHandler = new File([fileContents], refResolvedValue);
-                    const contentUrl = URL.createObjectURL(fileHandler);
-                    refResolvedValueToContentUrl.set(refResolvedValue, contentUrl);
-                    sendBack({
-                        type: 'updateContext',
-                        renderValue: contentUrl,
-                    });
-                    sendBack({
-                        type: 'resolvingRelatedValueSuccess',
-                        resolvedDisplayValue: contentUrl,
-                    });
-                    return true;
-                }
-            }
-            if (typeof propertyValueFromDb === 'string') {
-                // Check files for a filename that matches the propertyValue
-                if (propertyRecordSchema &&
-                    propertyRecordSchema.refValueType === 'ImageSrc') {
-                    let contentUrl;
-                    if (storageTransactionIdToContentUrl.has(propertyValueFromDb)) {
-                        contentUrl =
-                            storageTransactionIdToContentUrl.get(propertyValueFromDb);
-                    }
-                    if (!contentUrl) {
-                        const imageFileExists = yield fs.promises.exists(`/images/${propertyValue}`);
-                        if (imageFileExists) {
-                            const fileContents = yield fs.promises.readFile(`/images/${propertyValue}`);
-                            const fileHandler = new File([fileContents], propertyValue);
-                            contentUrl = URL.createObjectURL(fileHandler);
-                            storageTransactionIdToContentUrl.set(propertyValueFromDb, contentUrl);
-                        }
-                    }
-                    if (contentUrl) {
-                        sendBack({
-                            type: 'updateContext',
-                            renderValue: contentUrl,
-                        });
-                        sendBack({
-                            type: 'resolvingRelatedValueSuccess',
-                            resolvedDisplayValue: contentUrl,
-                        });
-                        return true;
-                    }
-                }
-            }
-        }
-    });
-    _resolveRelatedValue().then((success) => {
-        // if (success) {
-        //   sendBack({
-        //     type: 'resolvingRelatedValueDone',
-        //   })
-        // }
-        // return
-        sendBack({
-            type: 'resolvingRelatedValueDone',
-        });
-    });
-});
-//   const eventKey = `storage.transaction.${initialValue}.contentUrl.response`
-//
-//   const contentUrlListener = async (event) => {
-//     console.log('[itemProperty] [constructor] contentUrlListener', event)
-//   }
-//
-//   eventEmitter.once(eventKey, contentUrlListener)
-//
-//   const ready = getArePropertyEventHandlersReady()
-//
-//   console.log('[itemProperty] [constructor] ready', ready)
-//
-//   eventEmitter.emit('storage.transaction.contentUrl.request', {
-//     storageTransactionId: initialValue,
-//   })
-// Related property values can either be seedUid or seedUid[]
-// let relatedSeedUid: string
-// let relatedSeedUids: string[]
-//
-// if (Array.isArray(propertyValue)) {
-//   relatedSeedUids = propertyValue
-// } else {
-//   relatedSeedUid = propertyValue
-// }
-//
-// if (relatedSeedUid) {
-//   console.log(
-//     `[property/actors] [resolveRelatedValue] seedUid: ${relatedSeedUid}`,
-//   )
-//   const latestVersionOfRelatedSeedQuery = await appDb.run(
-//     sql.raw(
-//       `
-//           SELECT local_id, uid, MAX(attestation_created_at)
-//           FROM versions
-//           WHERE seed_uid = '${relatedSeedUid}';
-//       `,
-//     ),
-//   )
-//   if (
-//     latestVersionOfRelatedSeedQuery &&
-//     latestVersionOfRelatedSeedQuery.rows &&
-//     latestVersionOfRelatedSeedQuery.rows.length > 0
-//   ) {
-//     const latestVersionOfRelatedSeed =
-//       latestVersionOfRelatedSeedQuery.rows[0]
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] latestVersionOfRelatedSeed',
-//       latestVersionOfRelatedSeed,
-//     )
-//     const storageIdQuery = await appDb.run(
-//       sql.raw(
-//         `
-//             SELECT property_value, MAX(attestation_created_at), ref_resolved_display_value, ref_resolved_value
-//             FROM metadata
-//             WHERE seed_uid = '${relatedSeedUid}'
-//               AND property_name = 'storageTransactionId';
-//         `,
-//       ),
-//     )
-//
-//     if (
-//       storageIdQuery &&
-//       storageIdQuery.rows &&
-//       storageIdQuery.rows.length > 0
-//     ) {
-//       const storageId = storageIdQuery.rows[0][0]
-//
-//       if (!storageId) {
-//         console.error(
-//           `storageId not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
-//         )
-//       }
-//
-//       const resolvedDisplayValue = storageIdQuery.rows[0][2]
-//       let resolvedValue = storageIdQuery.rows[0][3]
-//
-//       if (resolvedDisplayValue && resolvedValue) {
-//         sendBack({
-//           type: 'resolvingRelatedValueSuccess',
-//           resolvedDisplayValue,
-//           resolvedValue,
-//         })
-//         return
-//       }
-//
-//       console.log(
-//         '[property/actors] [resolveRelatedValue] storageId',
-//         storageId,
-//       )
-//
-//       const contentUrl = await convertTxIdToImageSrc(storageId)
-//
-//       if (!contentUrl) {
-//         throw new Error(
-//           `contentUrl not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
-//         )
-//       }
-//
-//       await appDb.run(
-//         sql.raw(
-//           `UPDATE metadata
-//            SET ref_resolved_display_value = '${contentUrl}',
-//                ref_resolved_value         = '${storageId}'
-//            WHERE seed_uid = '${relatedSeedUid}'
-//              AND property_name = 'storageTransactionId';
-//           `,
-//         ),
-//       )
-//
-//       sendBack({
-//         type: 'resolvingRelatedValueSuccess',
-//         resolvedDisplayValue: contentUrl,
-//         resolvedValue: storageId,
-//       })
-//     }
-//   }
-//
-//   const versionUidQuery = await appDb.run(
-//     sql.raw(
-//       `
-//           SELECT uid
-//           FROM versions
-//           WHERE seed_uid = '${relatedSeedUid}';
-//       `,
-//     ),
-//   )
-//
-//   if (
-//     versionUidQuery &&
-//     versionUidQuery.rows &&
-//     versionUidQuery.rows.length > 0
-//   ) {
-//     const versionUids = versionUidQuery.rows.map((row) => row[0])
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] versionUids',
-//       versionUids,
-//     )
-//     const { itemProperties } = await easClient.request(GET_PROPERTIES, {
-//       where: {
-//         refUID: {
-//           in: versionUids,
-//         },
-//         decodedDataJson: {
-//           contains: 'storage_transaction_id',
-//         },
-//       },
-//     })
-//
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] itemProperties',
-//       itemProperties,
-//     )
-//
-//     if (itemProperties && itemProperties.length > 0) {
-//       await savePropertiesToDb(itemProperties)
-//     }
-//   }
-// }
-
-const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) => {
-    const { propertyInstances } = context;
-    if (!propertyInstances) {
-        throw new Error(`propertyInstances not found for ${context.seedLocalId}`);
-    }
-    if (!propertyInstances.has('storageTransactionId')) {
-        return;
-    }
-    const storageTransactionId = propertyInstances.get('storageTransactionId');
-    const _resolveRemoteStorage = () => __awaiter(void 0, void 0, void 0, function* () {
-        const path = yield import('path-browserify');
-        const { fs } = yield import('@zenfs/core');
-        const filesDirExists = yield fs.promises.exists('/files');
-        if (!filesDirExists) {
-            yield fs.promises.mkdir('/files');
-        }
-        const htmlDir = path.join('/files', 'html');
-        const htmlExists = yield fs.promises.exists(htmlDir);
-        if (htmlExists) {
-            const htmlFiles = yield fs.promises.readdir(htmlDir);
-            const matchingHtmlFile = htmlFiles.find((file) => file === `${storageTransactionId}.html`);
-            if (matchingHtmlFile) {
-                const htmlString = yield fs.promises.readFile(path.join(htmlDir, matchingHtmlFile), 'utf8');
-                sendBack({
-                    type: 'updateValue',
-                    propertyName: 'html',
-                    propertyValue: htmlString,
-                });
-            }
-        }
-        if (!htmlExists) {
-            yield fs.promises.mkdir(htmlDir);
-        }
-        const jsonDir = path.join('/files', 'json');
-        const jsonExists = yield fs.promises.exists(jsonDir);
-        if (jsonExists) {
-            const jsonFiles = yield fs.promises.readdir(jsonDir);
-            const matchingJsonFile = jsonFiles.find((file) => file === `${storageTransactionId}.json`);
-            if (matchingJsonFile) {
-                const jsonString = yield fs.promises.readFile(path.join(jsonDir, matchingJsonFile), 'utf8');
-                sendBack({
-                    type: 'updateValue',
-                    propertyName: 'json',
-                    propertyValue: jsonString,
-                });
-            }
-        }
-        if (!jsonExists) {
-            yield fs.promises.mkdir(jsonDir);
-        }
-    });
-    _resolveRemoteStorage().then(() => {
-        sendBack({ type: 'resolveRemoteStorageSuccess' });
-        return;
-    });
-});
-
-const updateMetadata = (metadataValues) => __awaiter(void 0, void 0, void 0, function* () {
-    const appDb = getAppDb();
-    const { localId } = metadataValues, rest = __rest(metadataValues, ["localId"]);
-    if (!localId) {
-        throw new Error('No localId provided to updateMetadata');
-    }
-    yield appDb.update(metadata).set(rest).where(eq(metadata.localId, localId));
-});
-
-const logger$m = debug('app:property:actors:hydrateFromDb');
-const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, itemModelName, } = context;
-    let propertyName = propertyNameRaw;
-    if (propertyRecordSchema &&
-        propertyRecordSchema.ref &&
-        propertyRecordSchema.dataType === 'Relation' &&
-        !propertyNameRaw.endsWith('Id')) {
-        propertyName = propertyNameRaw + 'Id';
-    }
-    if (propertyRecordSchema &&
-        propertyRecordSchema.ref &&
-        propertyRecordSchema.dataType === 'List' &&
-        !propertyNameRaw.endsWith('Ids')) {
-        propertyName = propertyNameRaw + 'Ids';
-    }
-    const _hydrateFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        const appDb = getAppDb();
-        const isRelation = propertyRecordSchema &&
-            propertyRecordSchema.ref &&
-            propertyRecordSchema.dataType === 'Relation';
-        const whereClauses = [];
-        if (isRelation) {
-            let missingPropertyNameVariant;
-            if (propertyName.endsWith('Id')) {
-                missingPropertyNameVariant = propertyName.slice(0, -2);
-            }
-            if (!propertyName.endsWith('Id')) {
-                missingPropertyNameVariant = propertyName + 'Id';
-            }
-            if (missingPropertyNameVariant) {
-                whereClauses.push(or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, missingPropertyNameVariant)));
-            }
-            if (!missingPropertyNameVariant) {
-                whereClauses.push(eq(metadata.propertyName, propertyName));
-            }
-        }
-        else {
-            whereClauses.push(eq(metadata.propertyName, propertyName));
-        }
-        if (seedUid) {
-            whereClauses.push(eq(metadata.seedUid, seedUid));
-        }
-        if (seedLocalId) {
-            whereClauses.push(eq(metadata.seedLocalId, seedLocalId));
-        }
-        const rows = yield appDb
-            .select()
-            .from(metadata)
-            .where(and(...whereClauses))
-            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'));
-        if (!rows || !rows.length) {
-            return;
-        }
-        const firstRow = rows[0];
-        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, localStorageDir, } = firstRow;
-        let { refResolvedDisplayValue, refResolvedValue } = firstRow;
-        let propertyValueProcessed = propertyValueFromDb;
-        if (propertyName && !propertyNameFromDb) {
-            logger$m(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
-        }
-        if (propertyName &&
-            propertyNameFromDb &&
-            !propertyNameFromDb.includes(propertyName) &&
-            !propertyName.includes(propertyNameFromDb) &&
-            propertyNameFromDb !== propertyName) {
-            logger$m(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
-        }
-        if (propertyValue && propertyValueFromDb !== propertyValue) {
-            logger$m(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
-        }
-        if (seedLocalIdFromDb !== seedLocalId) {
-            logger$m(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
-        }
-        if (seedUidFromDb !== seedUid) {
-            logger$m(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
-        }
-        if (propertyRecordSchema &&
-            propertyRecordSchema.refValueType === 'ImageSrc') {
-            let shouldReadFromFile = true;
-            if (refResolvedValue &&
-                refResolvedDisplayValue &&
-                refResolvedDisplayValue.includes('http')) {
-                try {
-                    const response = yield fetch(refResolvedDisplayValue, {
-                        method: 'HEAD',
-                    });
-                    // Check if the status is in the 200-299 range
-                    if (response.ok) {
-                        shouldReadFromFile = false;
-                    }
-                }
-                catch (error) {
-                    shouldReadFromFile = true;
-                }
-            }
-            if (shouldReadFromFile) {
-                let dir = localStorageDir;
-                if (!dir &&
-                    propertyRecordSchema &&
-                    propertyRecordSchema.refValueType === 'ImageSrc') {
-                    dir = 'images';
-                }
-                dir = dir.replace(/^\//, '');
-                if (!refResolvedValue &&
-                    propertyValueFromDb &&
-                    propertyValueFromDb.length === 66) {
-                    const storageTransactionQuery = yield appDb
-                        .select({
-                        propertyValue: metadata.propertyValue,
-                    })
-                        .from(metadata)
-                        .where(and(eq(metadata.seedUid, propertyValueFromDb), eq(metadata.propertyName, 'storageTransactionId')));
-                    if (storageTransactionQuery && storageTransactionQuery.length > 0) {
-                        const row = storageTransactionQuery[0];
-                        refResolvedValue = row.propertyValue;
-                        console.log('storageTransactionId', refResolvedValue);
-                        yield updateMetadata({
-                            localId,
-                            refResolvedValue,
-                            localStorageDir: '/images',
-                        });
-                    }
-                }
-                const dirPath = `/files/${dir}`;
-                const files = yield fs.promises.readdir(dirPath);
-                const matchingFiles = files.filter((file) => {
-                    return path.basename(file).includes(refResolvedValue);
-                });
-                let fileExists = false;
-                let filename;
-                let filePath;
-                if (matchingFiles && matchingFiles.length > 0) {
-                    fileExists = true;
-                    filename = matchingFiles[0];
-                    filePath = `/files/${dir}/${filename}`;
-                }
-                if (fileExists && filename && filePath) {
-                    const fileContents = yield fs.promises.readFile(filePath);
-                    const fileHandler = new File([fileContents], filename);
-                    refResolvedDisplayValue = URL.createObjectURL(fileHandler);
-                    yield updateMetadata({
-                        localId,
-                        refResolvedValue: filename,
-                    });
-                }
-            }
-        }
-        if (propertyRecordSchema &&
-            propertyRecordSchema.dataType === 'List' &&
-            propertyRecordSchema.ref &&
-            typeof propertyValueFromDb === 'string') {
-            propertyValueProcessed = propertyValueFromDb.split(',');
-        }
-        sendBack({
-            type: 'updateContext',
-            localId,
-            uid,
-            propertyValue: propertyValueProcessed,
-            seedLocalId: seedLocalIdFromDb,
-            seedUid: seedUidFromDb,
-            versionLocalId: versionLocalIdFromDb,
-            versionUid: versionUidFromDb,
-            schemaUid: schemaUidFromDb,
-            refValueType,
-            localStorageDir,
-            resolvedValue: refResolvedValue,
-            resolvedDisplayValue: refResolvedDisplayValue,
-            renderValue: refResolvedDisplayValue,
-            populatedFromDb: true,
-        });
-        if (propertyRecordSchema &&
-            propertyRecordSchema.storageType &&
-            propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = yield import('./index-D5tYjtxh.js');
-            const item = yield Item.find({
-                seedLocalId,
-                modelName: itemModelName,
-            });
-            if (item) {
-                const filePath = `/files/${localStorageDir}/${refResolvedValue}`;
-                const exists = yield fs.promises.exists(filePath);
-                if (!exists) {
-                    return;
-                }
-                const renderValue = yield fs.promises.readFile(filePath, 'utf8');
-                const property = item.properties[propertyName];
-                property.getService().send({ type: 'updateContext', renderValue });
-                return;
-            }
-        }
-    });
-    _hydrateFromDb().then(() => {
-        sendBack({ type: 'hydrateFromDbSuccess' });
-    });
-});
-
-const escapeSqliteString = (value) => {
-    if (typeof value !== 'string') {
-        throw new Error(`Value must be a string, instead got: ${JSON.stringify(value)}`);
-    }
-    return value.replace(/'/g, "''");
-};
-const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
-    const appDb = getAppDb();
-    if (!appDb) {
-        return new Promise((resolve) => {
-            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
-                const addresses = yield getAddressesFromDb();
-                resolve(addresses);
-            }), 500);
-        });
-    }
-    const appStatesRecords = yield appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, 'addresses'))
-        .limit(1);
-    if (!appStatesRecords || appStatesRecords.length === 0) {
-        throw new Error('No appStatesRecords for addresses found');
-    }
-    const addressRecord = appStatesRecords[0];
-    const addressArrayString = addressRecord.value;
-    if (!addressArrayString) {
-        throw new Error('No addresses found');
-    }
-    return JSON.parse(addressArrayString);
-});
-
-const getVersionData$1 = () => {
-    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$1();
-    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,
-        latestVersionUid: versionData.latestVersionUid,
-        latestVersionLocalId: versionData.latestVersionLocalId,
-        createdAt: seeds.createdAt,
-    })
-        .from(seeds)
-        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-        .where(and(gt(versionData.versionsCount, 0), ...conditions))
-        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
-    const itemsData = (yield query);
-    return itemsData;
-});
-
-const createVersion = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, seedType, uid, }) {
-    const appDb = getAppDb();
-    const newVersionLocalId = generateId();
-    yield appDb.insert(versions).values({
-        localId: newVersionLocalId,
-        createdAt: Date.now(),
-        seedLocalId,
-        seedUid: seedUid !== null && seedUid !== void 0 ? seedUid : 'NULL',
-        seedType,
-        uid: uid || 'NULL',
-    });
-    return newVersionLocalId;
+    const newVersionLocalId = generateId();
+    yield appDb.insert(versions).values({
+        localId: newVersionLocalId,
+        createdAt: Date.now(),
+        seedLocalId,
+        seedUid: seedUid !== null && seedUid !== void 0 ? seedUid : 'NULL',
+        seedType,
+        uid: uid || 'NULL',
+    });
+    return newVersionLocalId;
 });
 
 const createMetadata = (metadataValues, propertyRecordSchema) => __awaiter(void 0, void 0, void 0, function* () {
@@ -1411,18 +714,119 @@ const createNewItem = (_a) => __awaiter(void 0, void 0, void 0, function* () {
         //   ),
         // )
     }
-    // eventEmitter.emit(`item.requestAll`, { modelName })
-    return {
-        modelName,
-        seedLocalId: newSeedId,
-        versionLocalId: newVersionId,
-    };
+    // eventEmitter.emit(`item.requestAll`, { modelName })
+    return {
+        modelName,
+        seedLocalId: newSeedId,
+        versionLocalId: newVersionId,
+    };
+});
+
+const eventEmitter = new EventEmitter();
+
+const getPropertyData$1 = (propertyName, seedLocalId, seedUid) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    const whereClauses = [
+        or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, propertyName + 'Id'), eq(metadata.propertyName, propertyName + 'Ids')),
+    ];
+    if (seedLocalId) {
+        whereClauses.push(eq(metadata.seedLocalId, seedLocalId));
+    }
+    if (seedUid) {
+        whereClauses.push(eq(metadata.seedUid, seedUid));
+    }
+    const rows = (yield appDb
+        .select()
+        .from(metadata)
+        .where(and(...whereClauses))
+        .orderBy(sql.raw(`COALESCE(attestation_created_at, created_at) DESC`)));
+    if (!rows || rows.length === 0) {
+        return;
+    }
+    const row = rows[0];
+    return Object.assign(Object.assign({}, row), { itemModelName: startCase(row.modelType) });
+});
+const seedUidToStorageTransactionId = new Map();
+const getStorageTransactionIdForSeedUid = (seedUid) => __awaiter(void 0, void 0, void 0, function* () {
+    if (seedUidToStorageTransactionId.has(seedUid)) {
+        return seedUidToStorageTransactionId.get(seedUid);
+    }
+    const appDb = getAppDb();
+    const results = (yield appDb
+        .select({
+        storageTransactionId: metadata.propertyValue,
+    })
+        .from(metadata)
+        .where(and(eq(metadata.seedUid, seedUid), eq(metadata.propertyName, 'storageTransactionId'))));
+    if (!results || results.length === 0) {
+        return;
+    }
+    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
+    return results[0].storageTransactionId;
+});
+const getRelationValueData = (propertyValue) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    const rows = (yield appDb
+        .select({
+        propertyValue: metadata.propertyValue,
+        attestationCreatedAt: max(metadata.attestationCreatedAt),
+        refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+        refResolvedValue: metadata.refResolvedValue,
+        refSeedType: metadata.refSeedType,
+        easDataType: metadata.easDataType,
+    })
+        .from(metadata)
+        .where(eq(metadata.propertyValue, propertyValue)));
+    if (!rows || rows.length === 0) {
+        return;
+    }
+    return rows[0];
+});
+const getExistingItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, }) {
+    const existingItemStatement = `SELECT local_id, uid, created_at
+                                 FROM seeds
+                                 WHERE (uid IS NOT NULL
+                                     AND uid != ''
+                                     AND uid != 'undefined'
+                                     AND uid != 'null'
+                                     AND uid != 'false'
+                                     AND uid != '0'
+                                     AND uid != 0
+                                     AND uid = '${seedUid}'
+                                     )
+                                    OR (
+                                     local_id IS NOT NULL
+                                         AND local_id != ''
+                                         AND local_id != 'undefined'
+                                         AND local_id != 'null'
+                                         AND local_id != 'false'
+                                         AND local_id != '0'
+                                         AND local_id != 0
+                                         AND local_id = '${seedLocalId}'
+                                     );
+  `;
+    const { rows } = yield runQueryForStatement(existingItemStatement);
+    let existingItem;
+    if (rows && rows.length > 0) {
+        // We know the zero index is versionLocalId because we specifically asked for it first
+        // in the SELECT statement above. Same with the rest of the indexes.
+        let matchingRow = rows.find((row) => row[1] === seedUid);
+        if (!matchingRow) {
+            matchingRow = rows.find((row) => row[0] === seedLocalId);
+        }
+        if (matchingRow) {
+            existingItem = {
+                seedLocalId: matchingRow[0],
+                seedUid: matchingRow[1],
+                createdAt: matchingRow[2],
+            };
+        }
+    }
+    return existingItem;
 });
 
-const eventEmitter = new EventEmitter();
-
 var _a$2;
-const logger$l = debug('app:property:class');
+const logger$n = debug('app:property:class');
 const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
@@ -1472,7 +876,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$l('List property value is not JSON', e);
+                            logger$n('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -1555,7 +959,7 @@ class ItemProperty {
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$l(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$n(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
@@ -1610,7 +1014,7 @@ class ItemProperty {
                 });
                 return instance;
             }
-            const propertyData = yield getPropertyData(propertyName, seedLocalId, seedUid);
+            const propertyData = yield getPropertyData$1(propertyName, seedLocalId, seedUid);
             if (!propertyData) {
                 return;
             }
@@ -1702,7 +1106,7 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$l(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$n(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
@@ -1724,7 +1128,7 @@ const waitForDb = fromCallback(({ sendBack }) => {
     });
 });
 
-const initialize$2 = fromCallback(({ sendBack, input: { context } }) => {
+const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
     const { seedLocalId, seedUid, ModelClass } = context;
     const modelName = ModelClass.originalConstructor.name;
     const modelNamePlural = pluralize(modelName);
@@ -1981,6 +1385,38 @@ const GET_ALL_PROPERTIES_FOR_ALL_VERSIONS = graphql(/* GraphQL */ `
   }
 `);
 
+const escapeSqliteString = (value) => {
+    if (typeof value !== 'string') {
+        throw new Error(`Value must be a string, instead got: ${JSON.stringify(value)}`);
+    }
+    return value.replace(/'/g, "''");
+};
+const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    if (!appDb) {
+        return new Promise((resolve) => {
+            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                const addresses = yield getAddressesFromDb();
+                resolve(addresses);
+            }), 500);
+        });
+    }
+    const appStatesRecords = yield appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'addresses'))
+        .limit(1);
+    if (!appStatesRecords || appStatesRecords.length === 0) {
+        throw new Error('No appStatesRecords for addresses found');
+    }
+    const addressRecord = appStatesRecords[0];
+    const addressArrayString = addressRecord.value;
+    if (!addressArrayString) {
+        throw new Error('No addresses found');
+    }
+    return JSON.parse(addressArrayString);
+});
+
 const getModelSchemas = () => __awaiter(void 0, void 0, void 0, function* () {
     const models$1 = getModels();
     const modelRecords = [];
@@ -2308,6 +1744,7 @@ const saveEasPropertiesToDb = (_a) => __awaiter(void 0, [_a], void 0, function*
     let insertPropertiesQuery = `INSERT INTO metadata (local_id, uid, schema_uid, property_name, property_value,
                                                      eas_data_type, version_uid, version_local_id, seed_uid,
                                                      seed_local_id, model_type, ref_value_type, ref_seed_type,
+                                                     ref_schema_uid,
                                                      created_at, attestation_created_at, attestation_raw,
                                                      local_storage_dir, ref_resolved_value)
   VALUES `;
@@ -2316,17 +1753,20 @@ const saveEasPropertiesToDb = (_a) => __awaiter(void 0, [_a], void 0, function*
         const propertyLocalId = generateId();
         const metadata = JSON.parse(property.decodedDataJson)[0].value;
         let propertyNameSnake = metadata.name;
-        if (!propertyNameSnake) {
-            propertyNameSnake = metadata.name;
-        }
         if (!propertyNameSnake) {
             console.warn('[item/events] [syncDbWithEas] no propertyName found for property: ', property);
-            return;
+            continue;
         }
         let isRelation = false;
         let refValueType;
         let refSeedType;
+        let refSchemaUid;
         let isList = false;
+        const schemaUid = property.schemaId;
+        setSchemaUidForSchemaDefinition({
+            text: propertyNameSnake,
+            schemaUid,
+        });
         if ((propertyNameSnake.endsWith('_id') ||
             propertyNameSnake.endsWith('_ids')) &&
             propertyNameSnake !== 'storage_transaction_id' &&
@@ -2359,12 +1799,14 @@ const saveEasPropertiesToDb = (_a) => __awaiter(void 0, [_a], void 0, function*
             const relatedSeed = itemSeeds.find((seed) => seed.id === metadata.value);
             if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
                 refSeedType = relatedSeed.schema.schemaNames[0].name;
+                refSchemaUid = relatedSeed.schemaId;
             }
         }
         if (isRelation && isList) {
             const relatedSeeds = itemSeeds.filter((seed) => metadata.value.includes(seed.id));
             if (relatedSeeds && relatedSeeds.length > 0) {
                 refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
+                refSchemaUid = relatedSeeds[0].schemaId;
             }
         }
         const propertyName = camelCase(propertyNameSnake);
@@ -2389,6 +1831,7 @@ const saveEasPropertiesToDb = (_a) => __awaiter(void 0, [_a], void 0, function*
                          '${versionLocalId}', '${seedUid}', '${seedLocalId}', 
                          '${modelType}', ${refValueType ? `'${refValueType}'` : 'NULL'}, 
                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                         ${refSchemaUid ? `'${refSchemaUid}'` : 'NULL'},
                          ${Date.now()}, ${attestationCreatedAt}, '${attestationRaw}',
                          ${'NULL'},
                          ${'NULL'})`;
@@ -2515,8 +1958,8 @@ const syncDbWithEasHandler = throttle((_) => __awaiter(void 0, void 0, void 0, f
     trailing: false,
 });
 
-const logger$k = debug('app:services:global:actors:initialize');
-const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
+const logger$m = debug('app:services:global:actors:initialize');
+const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints } = context;
     const { addresses } = event;
     let environment = 'browser';
@@ -2536,7 +1979,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
         const _initInternal = () => __awaiter(void 0, void 0, void 0, function* () {
             return new Promise((resolve) => {
                 internalSubscription = internalService.subscribe((snapshot) => {
-                    logger$k('[sdk] [internal] snapshot', snapshot);
+                    logger$m('[sdk] [internal] snapshot', snapshot);
                     if (snapshot.value === 'ready') {
                         resolve();
                     }
@@ -2569,15 +2012,21 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
             }
             sendBack(Object.assign({ type: GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES }, payloadObj));
         });
+        const _initEas = () => __awaiter(void 0, void 0, void 0, function* () {
+            yield fetchSchemaUids();
+        });
         _initFileSystem().then(() => {
-            logger$k('[global/actors] File system initialized');
+            logger$m('[global/actors] File system initialized');
         });
         _initInternal()
             .then(() => {
             return _initAllItemsServices();
         })
             .then(() => {
-            logger$k('[global/actors] Internal initialized');
+            return _initEas();
+        })
+            .then(() => {
+            logger$m('[global/actors] Internal initialized');
             sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
             internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
         });
@@ -2591,7 +2040,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$j = debug('app:services:global:actors:getSchemaForModel');
+const logger$l = debug('app:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -2607,12 +2056,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$j('[service/actor] [getSchemaForModel] model:', model);
+    logger$l('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$i = debug('app:services:global:actors:addModelsToDb');
+const logger$k = 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* () {
@@ -2621,12 +2070,12 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-wQXee2fb.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-C37yDUmq.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$i('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$k('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = yield appDb
                 .select()
@@ -2636,7 +2085,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 yield appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$i('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$k('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = yield appDb
                     .select({
                     id: models.id,
@@ -2706,10 +2155,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$h = debug('app:services:db:actors:checkStatus');
+const logger$j = debug('app:services:db:actors:checkStatus');
 const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     const { dbName } = context;
-    logger$h('[db/actors] checkStatus context', context);
+    logger$j('[db/actors] checkStatus context', context);
     const pathToDir = `${BROWSER_FS_TOP_DIR}`;
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
@@ -2740,9 +2189,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$g = debug('app:services:db:actors:connectToDb');
+const logger$i = debug('app:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$g('[db/actors] connectToDb context', context);
+    logger$i('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     let isConnecting = false;
     let dbId;
@@ -2755,16 +2204,16 @@ const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
         const sqliteWasmClient = yield getSqliteWasmClient();
         //@ts-ignore
         response = yield sqliteWasmClient('config-get', {});
-        logger$g(response);
-        logger$g('Running SQLite3 version', response.result.version.libVersion);
+        logger$i(response);
+        logger$i('Running SQLite3 version', response.result.version.libVersion);
         //@ts-ignore
         response = yield sqliteWasmClient('open', {
             filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
         });
-        logger$g(response);
+        logger$i(response);
         dbId = response.dbId;
         // logger(`dbId: ${dbId}`)
-        logger$g('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
+        logger$i('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
     });
     const interval = setInterval(() => {
         // TODO: Add a timeout
@@ -2821,7 +2270,7 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$f = debug('app:services:db:actors:migrate');
+const logger$h = 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();
@@ -2887,7 +2336,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$f('[db/actors] migrate context', context);
+    logger$h('[db/actors] migrate context', context);
     const schemaGlobString = `${BROWSER_FS_TOP_DIR}/schema/*`;
     let journalExists = false;
     // const _initFs = async (): Promise<void> => {
@@ -3051,7 +2500,7 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$e = debug('app:services:db:machine');
+const logger$g = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -3072,7 +2521,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$e('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$g('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -3081,8 +2530,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$e('[db/machine] updateHasFiles event:', event);
-                    logger$e('[db/machine] updateHasFiles context:', context);
+                    logger$g('[db/machine] updateHasFiles event:', event);
+                    logger$g('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -3298,7 +2747,7 @@ const prepareDb = fromCallback(({ sendBack }) => {
     };
 });
 
-const logger$d = debug('app:services:internal:helpers');
+const logger$f = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -3374,7 +2823,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$d(`[Error] Failed to download file from ${url}:`, error);
+        logger$f(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 });
@@ -3412,7 +2861,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$d('[syncDbFiles] Files synced!');
+    logger$f('[syncDbFiles] Files synced!');
 });
 
 const uploadBinaryData = fromCallback(({ sendBack, receive, input }) => { });
@@ -3651,7 +3100,7 @@ const saveAppState = (key, value) => __awaiter(void 0, void 0, void 0, function*
     });
 });
 
-const logger$c = debug('app:files:download');
+const logger$e = 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 });
@@ -3735,7 +3184,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$c(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$e(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 yield saveAppState('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -3775,7 +3224,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             //   string: true,
             // })
             if (!dataString) {
-                logger$c(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
+                logger$e(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
             let contentType = identifyString(dataString);
             if (contentType !== 'json' &&
@@ -3783,7 +3232,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 contentType !== 'html') {
                 const possibleImageType = getDataTypeFromString(dataString);
                 if (!possibleImageType) {
-                    logger$c(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    logger$e(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
                 }
                 contentType = possibleImageType;
@@ -3850,7 +3299,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             }
         }
         catch (error) {
-            logger$c(error);
+            logger$e(error);
         }
     }
 });
@@ -3896,14 +3345,14 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$b = debug('app:internal:actors:configureFs');
+const logger$d = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService } = context;
-    logger$b('[internal/actors] [configureFs] Configuring FS');
+    logger$d('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$b('[internal/actors] [configureFs] calling _configureFs');
-        logger$b('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$b('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$d('[internal/actors] [configureFs] calling _configureFs');
+        logger$d('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$d('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         yield waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -3932,7 +3381,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
         //     }
         //   }, 200)
         // })
-        logger$b('[internal/actors] [configureFs] fs configured!');
+        logger$d('[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
@@ -3945,7 +3394,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$a = debug('app:services:internal:actors:saveConfig');
+const logger$c = debug('app:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     if (typeof window === 'undefined') {
         console.error('seedInitBrowser called from non-browser context');
@@ -3996,20 +3445,20 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                 },
                 setWhere: sql `key = 'addresses'`,
             });
-            logger$a('[sdk] [internal/actors] Should be done saving');
+            logger$c('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     });
     _saveConfig().then(() => {
-        logger$a('[sdk] [internal/actors] Successfully saved config');
+        logger$c('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$9 = debug('app:services:internal:actors:loadAppDb');
+const logger$b = debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -4030,7 +3479,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$9('[sdk] [internal/actors] Successfully loaded app DB');
+        logger$b('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -4039,7 +3488,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$8 = debug('app:services:internal:machine');
+const logger$a = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
@@ -4138,7 +3587,7 @@ const internalMachine = setup({
                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                     target: SAVING_CONFIG,
                     actions: () => {
-                        logger$8('[sdk] [internal/index] App DB loaded!');
+                        logger$a('[sdk] [internal/index] App DB loaded!');
                     },
                 },
             },
@@ -4164,7 +3613,7 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$8('[sdk] [internal/index] Ready!');
+                logger$a('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -4179,7 +3628,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$8('[sdk] [internal/index] Error!');
+                logger$a('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -4223,7 +3672,7 @@ const internalMachine = setup({
 // })
 // internalService.start()
 
-const initialize = fromCallback(({ sendBack, input: { context } }) => {
+const initialize$1 = fromCallback(({ sendBack, input: { context } }) => {
     const { modelName, modelAddedToDb, ModelClass, times } = context;
     const newTimes = {
         initialize: {
@@ -4415,7 +3864,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$7 = debug('app:allItemsActors:fetchSeeds');
+const logger$9 = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -4425,7 +3874,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$7(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$9(`[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); }),
@@ -4644,7 +4093,7 @@ const itemMachineAll = setup({
         input: {},
     },
     actors: {
-        initialize,
+        initialize: initialize$1,
         fetchDbData,
         fetchSeeds,
         fetchVersions,
@@ -4870,13 +4319,13 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$6 = debug('app:services:publish:actors:upload');
+const logger$8 = 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$6('no item with localId', localId);
+            logger$8('no item with localId', localId);
             return false;
         }
         const editedProperties = yield item.getEditedProperties();
@@ -5006,7 +4455,7 @@ const globalMachine = setup({
         input: {},
     },
     actors: {
-        initialize: initialize$1,
+        initialize: initialize$2,
         addModelsToDb,
         getSchemaForModel,
         savePublishService,
@@ -5520,7 +4969,7 @@ const itemMachineSingle = setup({
     },
     actors: {
         waitForDb,
-        initialize: initialize$2,
+        initialize: initialize$3,
         hydrateExistingItem,
         hydrateNewItem,
         fetchDataFromEas,
@@ -5710,7 +5159,7 @@ const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoc
     return rows[0];
 });
 
-const logger$5 = debug('app:db:queries:getItem');
+const logger$7 = 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');
@@ -5718,7 +5167,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$5('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$7('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -5745,7 +5194,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$5('[db/queries] [getItemDataFromDb] no itemDataRows');
+        logger$7('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -5786,130 +5235,215 @@ const getItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName,
     return Item.create(itemInitObj);
 });
 
-const getSchemaForItemProperty = (_a) => __awaiter(void 0, [_a], void 0, function* ({ schemaUid, propertyName, easDataType, }) {
-    const propertyNameSnakeCase = toSnakeCase(propertyName);
-    const isMissingSchemaUid = !schemaUid || schemaUid === 'null' || schemaUid === 'undefined';
-    let queryParams = {
-        where: {
-            id: {
-                equals: schemaUid,
-            },
-        },
-    };
-    if (easDataType) {
-        queryParams = {
-            where: {
-                schema: {
-                    equals: `${easDataType} ${propertyNameSnakeCase}`,
-                },
-            },
-        };
-    }
-    if (!easDataType && isMissingSchemaUid) {
-        queryParams = {
-            where: {
-                schemaNames: {
-                    some: {
-                        name: {
-                            equals: propertyNameSnakeCase,
-                        },
-                    },
-                },
-            },
-        };
-    }
-    const foundPropertySchema = yield queryClient.fetchQuery({
-        queryKey: [`getPropertySchema${propertyName}`],
-        queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return easClient.request(GET_SCHEMAS, queryParams); }),
-        networkMode: 'offlineFirst',
-    });
-    if (foundPropertySchema && foundPropertySchema.schemas.length > 0) {
-        return foundPropertySchema.schemas[0];
+const getVersionUid = (item) => {
+    let versionUid;
+    if (item.latestVersionUid &&
+        item.latestVersionUid !== 'NULL' &&
+        item.latestVersionUid !== 'undefined') {
+        versionUid = item.latestVersionUid;
+    }
+    return versionUid || ZERO_ADDRESS;
+};
+const getPropertyData = (itemProperty) => __awaiter(void 0, void 0, void 0, function* () {
+    const easDataType = INTERNAL_DATA_TYPES[itemProperty.propertyDef.dataType].eas;
+    let schemaUid = itemProperty.schemaUid;
+    const propertyNameForSchema = toSnakeCase(itemProperty.propertyName);
+    const schemaDef = `${easDataType} ${propertyNameForSchema}`;
+    if (!schemaUid) {
+        schemaUid = getSchemaUidForSchemaDefinition(schemaDef);
+        if (!schemaUid) {
+            const schema = yield getSchemaForItemProperty({
+                propertyName: 'version',
+                easDataType: 'bytes32',
+            });
+            if (schema) {
+                schemaUid = schema.id;
+            }
+        }
     }
+    return {
+        schemaUid,
+        easDataType,
+        schemaDef,
+        propertyNameForSchema,
+    };
 });
-
-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 localId = item.seedLocalId;
-    const seedIsRevocable = true;
-    const seedSchemaUid = item.schemaUid;
-    const seedUid = item.seedUid;
-    const versionSchemaUid = VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA;
-    const listOfAttestations = [];
-    const propertiesToUpdate = [];
-    for (const [propertyName, itemProperty] of Object.entries(item.properties)) {
-        if (!itemProperty.value || !itemProperty.propertyDef) {
+const getSegmentedItemProperties = (item) => {
+    const itemBasicProperties = [];
+    const itemRelationProperties = [];
+    const itemListProperties = [];
+    const itemStorageProperties = [];
+    for (const itemProperty of Object.values(item.properties)) {
+        if (!itemProperty.propertyDef) {
             continue;
         }
-        const easDataType = INTERNAL_DATA_TYPES[itemProperty.propertyDef.dataType].eas;
-        let schemaUid = itemProperty.schemaUid;
-        let propertyNameForSchema = propertyName;
-        let propertyValue = itemProperty.getService().getSnapshot()
-            .context.propertyValue;
         if (itemProperty.propertyDef.dataType === 'Relation') {
-            propertyNameForSchema = `${propertyName}Id`;
-        }
-        if (itemProperty.propertyDef.dataType === 'List' &&
-            itemProperty.propertyDef.ref) {
-            const singularPropertyName = pluralize.singular(propertyName);
-            propertyNameForSchema = `${singularPropertyName}${itemProperty.propertyDef.ref}Ids`;
-            if (typeof propertyValue === 'string' && propertyValue.length === 66) {
-                propertyValue = [propertyValue];
-            }
-            if (typeof propertyValue === 'string' && propertyValue.length > 66) {
-                try {
-                    propertyValue = JSON.parse(propertyValue);
-                }
-                catch (error) {
-                    console.log('No-op due to error: ', error);
-                }
-            }
+            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;
         }
-        const foundPropertySchema = yield getSchemaForItemProperty({
-            schemaUid,
-            propertyName: propertyNameForSchema,
-            easDataType,
-        });
-        if (!foundPropertySchema) {
-            throw new Error(`No schema found for property ${itemProperty.propertyName} ${itemProperty.localId}`);
+        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;
+        if (!value || basicProperty.uid) {
+            continue;
         }
-        schemaUid = foundPropertySchema.id;
+        const { schemaUid, easDataType, schemaDef } = yield getPropertyData(basicProperty);
+        const propertyNameForSchema = toSnakeCase(basicProperty.propertyName);
         const data = [
             {
-                name: toSnakeCase(propertyNameForSchema),
+                name: propertyNameForSchema,
                 type: easDataType,
-                value: propertyValue,
+                value,
             },
         ];
-        const easSchemaDefinition = foundPropertySchema.schema;
-        const dataEncoder = new SchemaEncoder(easSchemaDefinition);
+        const dataEncoder = new SchemaEncoder(schemaDef);
         const encodedData = dataEncoder.encodeData(data);
-        listOfAttestations.push({
+        itemPublishData.listOfAttestations.push({
             schema: schemaUid,
             data: [
                 Object.assign(Object.assign({}, defaultAttestationData), { data: encodedData }),
             ],
         });
     }
-    return [
-        {
-            localId,
-            seedIsRevocable,
-            seedSchemaUid,
+    return itemPublishData;
+});
+const processRelationProperty = (relationProperty, multiPublishPayload) => __awaiter(void 0, void 0, void 0, function* () {
+    const value = relationProperty.getService().getSnapshot()
+        .context.propertyValue;
+    if (!value || relationProperty.uid) {
+        return multiPublishPayload;
+    }
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(value);
+    const relatedItem = yield getItem({
+        seedLocalId,
+        seedUid,
+    });
+    if (!relatedItem) {
+        throw new Error(`No related item found for relation property: ${relationProperty.propertyName}`);
+    }
+    const versionUid = getVersionUid(relatedItem);
+    const seedSchemaUid = yield getSchemaUidForModel(relationProperty.propertyDef.ref);
+    let publishPayload = {
+        localId: relationProperty.localId,
+        seedIsRevocable: true,
+        versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+        seedUid: seedUid || ZERO_ADDRESS,
+        seedSchemaUid,
+        versionUid,
+        listOfAttestations: [],
+        propertiesToUpdate: [],
+    };
+    const { itemBasicProperties } = getSegmentedItemProperties(relatedItem);
+    publishPayload = yield processBasicProperties(itemBasicProperties, publishPayload);
+    multiPublishPayload.push(publishPayload);
+    return multiPublishPayload;
+});
+const processListProperty = (listProperty, multiPublishPayload) => __awaiter(void 0, void 0, void 0, function* () {
+    let value = listProperty.getService().getSnapshot().context.propertyValue;
+    if (!value || listProperty.uid) {
+        return multiPublishPayload;
+    }
+    const singularPropertyName = pluralize.singular(listProperty.propertyName);
+    `${singularPropertyName}${listProperty.propertyDef.ref}Ids`;
+    if (typeof value === 'string' && value.length === 66) {
+        value = [value];
+    }
+    if (typeof value === 'string' && value.length > 66) {
+        try {
+            value = JSON.parse(value);
+        }
+        catch (error) {
+            value = value.split(',');
+        }
+    }
+    for (const seedId of value) {
+        const { localId: seedLocalId, uid: seedUid } = getCorrectId(seedId);
+        const relatedItem = yield getItem({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            throw new Error(`No related item found for list property: ${listProperty.propertyName}`);
+        }
+        if (relatedItem.seedUid) {
+            return multiPublishPayload;
+        }
+        const versionUid = getVersionUid(relatedItem);
+        const seedSchemaUid = yield getSchemaUidForModel(listProperty.propertyDef.ref);
+        let publishPayload = {
+            localId: relatedItem.seedLocalId,
+            seedIsRevocable: true,
+            versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
             seedUid: seedUid || ZERO_ADDRESS,
-            versionUid: item.latestVersionUid || ZERO_ADDRESS,
-            versionSchemaUid,
-            listOfAttestations,
-            propertiesToUpdate,
-        },
-    ];
+            seedSchemaUid,
+            versionUid,
+            listOfAttestations: [],
+            propertiesToUpdate: [
+                {
+                    publishLocalId: listProperty.localId,
+                    propertySchemaUid: listProperty.schemaUid,
+                },
+            ],
+        };
+        const { itemBasicProperties } = getSegmentedItemProperties(relatedItem);
+        publishPayload = yield processBasicProperties(itemBasicProperties, publishPayload);
+        multiPublishPayload.push(publishPayload);
+    }
+    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');
+    }
+    // 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
+    // That means the Seed of the Item, plus any Seeds pointed to by Relations
+    let itemPublishData = {
+        localId: item.seedLocalId,
+        seedUid: item.seedUid || ZERO_ADDRESS,
+        seedIsRevocable: true,
+        seedSchemaUid: item.schemaUid,
+        versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+        versionUid: item.latestVersionUid || ZERO_ADDRESS,
+        listOfAttestations: [],
+        propertiesToUpdate: [],
+    };
+    const { itemBasicProperties, itemRelationProperties, itemListProperties, itemStorageProperties, } = getSegmentedItemProperties(item);
+    itemPublishData = yield processBasicProperties(itemBasicProperties, itemPublishData);
+    multiPublishPayload.push(itemPublishData);
+    for (const relationProperty of itemRelationProperties) {
+        multiPublishPayload = yield processRelationProperty(relationProperty, multiPublishPayload);
+    }
+    for (const listProperty of itemListProperties) {
+        multiPublishPayload = yield processListProperty(listProperty, multiPublishPayload);
+    }
+    return multiPublishPayload;
 });
 
 var _a$1;
@@ -6023,6 +5557,9 @@ class Item {
     }
     static create(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!props.modelName && props.type) {
+                props.modelName = capitalizeFirstLetter(props.type);
+            }
             if (props.seedUid || props.seedLocalId) {
                 const seedId = (props.seedUid || props.seedLocalId);
                 if (Item.instanceCache.has(seedId)) {
@@ -6162,7 +5699,7 @@ class Item {
 _a$1 = immerable;
 Item.instanceCache = new Map();
 
-const logger$4 = debug('app:react:services');
+const logger$6 = debug('app:react:services');
 const finalStrings = ['idle', 'ready', 'done', 'success', 'initialized'];
 const getServiceName = (service) => {
     let name = 'actor';
@@ -6209,7 +5746,7 @@ const getServiceUniqueKey = (service) => {
         snapshot = service.getSnapshot();
     }
     catch (error) {
-        logger$4('Error:', error);
+        logger$6('Error:', error);
         return uniqueKey;
     }
     if (snapshot) {
@@ -6313,7 +5850,7 @@ const useGlobalServiceStatus = () => {
     };
 };
 
-const logger$3 = debug('app:react:item');
+const logger$5 = debug('app:react:item');
 const useItem = ({ modelName, seedLocalId, seedUid }) => {
     // const [itemSubscription, setItemSubscription] = useState<
     //   Subscription | undefined
@@ -6390,7 +5927,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             seedUid,
         });
         if (!foundItem) {
-            logger$3('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            logger$5('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
             isReadingDb.current = false;
             return;
         }
@@ -6412,7 +5949,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
                 const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
                 if (!newItem) {
-                    logger$3('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    logger$5('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
                     return;
                 }
                 updateItem(newItem);
@@ -6439,19 +5976,131 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
         itemStatus,
     };
 };
-const useItems = ({ modelName, deleted }) => {
-    const [items, setItems] = useImmer([]);
-    const { status, internalStatus } = useGlobalServiceStatus();
-    const modelNameRef = useRef(modelName);
+const useItems = ({ modelName, deleted }) => {
+    const [items, setItems] = useImmer([]);
+    const { status, internalStatus } = useGlobalServiceStatus();
+    const modelNameRef = useRef(modelName);
+    const isReadingDb = useRef(false);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingDb.current || internalStatus !== 'ready') {
+            return;
+        }
+        isReadingDb.current = true;
+        const allItems = yield Item.all(modelNameRef.current, deleted);
+        setItems(() => []);
+        setItems(() => allItems);
+        isReadingDb.current = false;
+    }), [internalStatus]);
+    const listenerRef = useRef(readFromDb);
+    useEffect(() => {
+        listenerRef.current = readFromDb;
+    }, [readFromDb]);
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            listenerRef.current();
+        }
+    }, [internalStatus, status]);
+    useEffect(() => {
+        eventEmitter.addListener('item.requestAll', (event) => {
+            if (!event ||
+                !event.modelName ||
+                event.modelName !== modelNameRef.current) {
+                return;
+            }
+            listenerRef.current();
+        });
+        return () => {
+            eventEmitter.removeListener('item.requestAll', readFromDb);
+        };
+    }, []);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']),
+        isReadingDb,
+    };
+};
+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$4 = debug('app:react:property');
+const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
+    const [property, setProperty] = useState();
+    const [isInitialized, setIsInitialized] = useState(false);
+    const { internalStatus } = useGlobalServiceStatus();
     const isReadingDb = useRef(false);
+    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);
     const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (isReadingDb.current || internalStatus !== 'ready') {
+        if (internalStatus !== 'ready' ||
+            isReadingDb.current ||
+            (!seedLocalId && !seedUid)) {
             return;
         }
         isReadingDb.current = true;
-        const allItems = yield Item.all(modelNameRef.current, deleted);
-        setItems(() => []);
-        setItems(() => allItems);
+        const foundProperty = yield ItemProperty.find({
+            propertyName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!foundProperty) {
+            logger$4(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            isReadingDb.current = false;
+            return;
+        }
+        if (foundProperty.status === 'waitingForDb') {
+            foundProperty.getService().send({ type: 'waitForDbSuccess' });
+        }
+        setProperty(foundProperty);
+        setIsInitialized(true);
         isReadingDb.current = false;
     }), [internalStatus]);
     const listenerRef = useRef(readFromDb);
@@ -6460,292 +6109,829 @@ const useItems = ({ modelName, deleted }) => {
     }, [readFromDb]);
     useEffect(() => {
         if (internalStatus === 'ready') {
-            listenerRef.current();
+            readFromDb();
         }
-    }, [internalStatus, status]);
+    }, [internalStatus]);
     useEffect(() => {
-        eventEmitter.addListener('item.requestAll', (event) => {
-            if (!event ||
-                !event.modelName ||
-                event.modelName !== modelNameRef.current) {
-                return;
-            }
+        eventEmitter.addListener(`property.${seedUid || seedLocalId}.${propertyName}.update`, () => {
             listenerRef.current();
         });
         return () => {
-            eventEmitter.removeListener('item.requestAll', readFromDb);
+            eventEmitter.removeListener(`property.${seedUid || seedLocalId}.${propertyName}.update`);
         };
     }, []);
     return {
-        items: orderBy(items, [
-            (item) => item.lastVersionPublishedAt ||
-                item.attestationCreatedAt ||
-                item.createdAt,
-        ], ['desc']),
-        isReadingDb,
+        property,
+        isInitialized,
+        value,
+        status,
     };
 };
-const useItemIsReady = () => {
-    const [itemListenersReady, setItemListenersReady] = useState(false);
-    const itemEventListenersHandler = useCallback((_) => {
-        setItemListenersReady(true);
-    }, []);
+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(() => {
-        const areReady = getAreItemEventHandlersReady();
-        if (areReady) {
-            itemEventListenersHandler(true);
+        if (!item) {
+            return;
         }
-        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
+        const eventKey = `item.${item.seedLocalId}.property.update`;
+        eventEmitter.addListener(eventKey, updatePropertyObj);
         return () => {
-            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
+            eventEmitter.removeListener(eventKey, updatePropertyObj);
         };
-    }, []);
+    }, [item]);
     return {
-        isReady: itemListenersReady,
+        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$3 = debug('app:services:events');
+const handleServiceSaveState = (event) => {
+    const { state, serviceId } = event;
+    logger$3(`[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];
+    if (!service) {
+        console.log(`[saveServiceHandler] service not found: ${nameOfService}`);
+        return;
+    }
+    yield saveAppState(`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-C37yDUmq.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 getSchemaForItemProperty = (_a) => __awaiter(void 0, [_a], void 0, function* ({ schemaUid, propertyName, easDataType, }) {
+    const propertyNameSnakeCase = toSnakeCase(propertyName);
+    const isMissingSchemaUid = !schemaUid || schemaUid === 'null' || schemaUid === 'undefined';
+    let queryParams = {
+        where: {
+            id: {
+                equals: schemaUid,
+            },
+        },
     };
+    if (easDataType) {
+        queryParams = {
+            where: {
+                schema: {
+                    equals: `${easDataType} ${propertyNameSnakeCase}`,
+                },
+            },
+        };
+    }
+    if (!easDataType && isMissingSchemaUid) {
+        queryParams = {
+            where: {
+                schemaNames: {
+                    some: {
+                        name: {
+                            equals: propertyNameSnakeCase,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    const foundPropertySchema = yield queryClient.fetchQuery({
+        queryKey: [`getPropertySchema${propertyName}`],
+        queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return easClient.request(GET_SCHEMAS, queryParams); }),
+        networkMode: 'offlineFirst',
+    });
+    if (foundPropertySchema && foundPropertySchema.schemas.length > 0) {
+        return foundPropertySchema.schemas[0];
+    }
+});
+
+const schemaUidForSchemaDefinition = new Map();
+const setSchemaUidForSchemaDefinition = ({ text, schemaUid }) => {
+    const propertySnakeCase = toSnakeCase(text);
+    schemaUidForSchemaDefinition.set(propertySnakeCase, schemaUid);
 };
-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 getSchemaUidForSchemaDefinition = (schemaText) => {
+    const textSnakeCase = toSnakeCase(schemaText);
+    if (!schemaUidForSchemaDefinition.has(textSnakeCase)) {
+        return;
+    }
+    return schemaUidForSchemaDefinition.get(textSnakeCase);
 };
+const fetchSchemaUids = () => __awaiter(void 0, void 0, void 0, function* () {
+    const versionSchemaUid = yield getSchemaForItemProperty({
+        propertyName: 'version',
+        easDataType: 'bytes32',
+    });
+    if (versionSchemaUid) {
+        setSchemaUidForSchemaDefinition({
+            text: 'version',
+            schemaUid: versionSchemaUid,
+        });
+    }
+    const imageSchemaUid = yield getSchemaForItemProperty({
+        propertyName: 'image',
+        easDataType: 'bytes32',
+    });
+    if (imageSchemaUid) {
+        setSchemaUidForSchemaDefinition({
+            text: 'image',
+            schemaUid: imageSchemaUid,
+        });
+    }
+});
 
-const logger$2 = debug('app:react:property');
-const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
-    const [property, setProperty] = useState();
-    const [isInitialized, setIsInitialized] = useState(false);
-    const { internalStatus } = useGlobalServiceStatus();
-    const isReadingDb = useRef(false);
-    const value = useSelector(property === null || property === void 0 ? void 0 : property.getService(), (snapshot) => {
-        if (!snapshot || !snapshot.context) {
-            return;
+const initialize = fromCallback(({ sendBack, input: { context } }) => {
+    const { isRelation, propertyName, storageTransactionId } = context;
+    let { schemaUid } = context;
+    if (!schemaUid) {
+        schemaUid = getSchemaUidForSchemaDefinition(propertyName);
+        if (schemaUid) {
+            sendBack({ type: 'updateContext', schemaUid });
         }
-        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);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (internalStatus !== 'ready' ||
-            isReadingDb.current ||
-            (!seedLocalId && !seedUid)) {
+    }
+    if (isRelation) {
+        sendBack({ type: 'isRelatedProperty' });
+        sendBack({ type: 'initializeSuccess' });
+        return;
+    }
+    if (!isRelation) {
+        if ((propertyName !== 'html' && propertyName !== 'json') ||
+            !storageTransactionId) {
+            sendBack({ type: 'initializeSuccess' });
             return;
         }
-        isReadingDb.current = true;
-        const foundProperty = yield ItemProperty.find({
-            propertyName,
-            seedLocalId,
-            seedUid,
+        const _getContentsFromFileSystem = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (propertyName === 'html') {
+                const htmlFilePath = `/files/html/${storageTransactionId}.html`;
+                const exists = yield fs.promises.exists(htmlFilePath);
+                if (!exists) {
+                    return;
+                }
+                const renderValue = yield fs.promises
+                    .readFile(`/files/html/${storageTransactionId}.html`, 'utf8')
+                    .catch((error) => {
+                    console.warn('Error reading html file', error);
+                });
+                sendBack({ type: 'updateContext', renderValue });
+                return;
+            }
+            if (propertyName === 'json') {
+                const jsonFilePath = `/files/json/${storageTransactionId}.json`;
+                const exists = yield fs.promises.exists(jsonFilePath);
+                if (!exists) {
+                    return;
+                }
+                const renderValue = yield fs.promises
+                    .readFile(`/files/json/${storageTransactionId}.json`, 'utf8')
+                    .catch((error) => {
+                    console.warn('Error reading json file', error);
+                });
+                sendBack({ type: 'updateContext', renderValue });
+                return;
+            }
         });
-        if (!foundProperty) {
-            logger$2(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
-            isReadingDb.current = false;
+        _getContentsFromFileSystem().then(() => {
+            sendBack({ type: 'initializeSuccess' });
+        });
+    }
+});
+
+const logger$2 = debug('app:property:actors:resolveRelatedValue');
+const storageTransactionIdToContentUrl = new Map();
+const refResolvedValueToContentUrl = new Map();
+const seedUidToContentUrl = new Map();
+const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
+    const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
+    const _resolveRelatedValue = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
-        if (foundProperty.status === 'waitingForDb') {
-            foundProperty.getService().send({ type: 'waitForDbSuccess' });
+        let parsedValue;
+        try {
+            parsedValue = JSON.parse(propertyValue);
         }
-        setProperty(foundProperty);
-        setIsInitialized(true);
-        isReadingDb.current = false;
-    }), [internalStatus]);
-    const listenerRef = useRef(readFromDb);
-    useEffect(() => {
-        listenerRef.current = readFromDb;
-    }, [readFromDb]);
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            readFromDb();
+        catch (error) {
+            logger$2(`${propertyName} value is not a JSON string.`);
         }
-    }, [internalStatus]);
-    useEffect(() => {
-        eventEmitter.addListener(`property.${seedUid || seedLocalId}.${propertyName}.update`, () => {
-            listenerRef.current();
-        });
-        return () => {
-            eventEmitter.removeListener(`property.${seedUid || seedLocalId}.${propertyName}.update`);
-        };
-    }, []);
-    return {
-        property,
-        isInitialized,
-        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');
+        if (!parsedValue && seedUidToContentUrl.has(propertyValue)) {
+            const contentUrl = seedUidToContentUrl.get(propertyValue);
+            sendBack({
+                type: 'updateContext',
+                renderValue: contentUrl,
+            });
+            sendBack({
+                type: 'resolvingRelatedValueSuccess',
+                resolvedDisplayValue: contentUrl,
+            });
+            return true;
+        }
+        if (Array.isArray(propertyValue)) {
+            // TODO: Handle array of seedUids
+            logger$2(`${propertyName} value is an array of seedUids`);
             return;
         }
-        const { propertyName, propertyValue } = event;
-        if (!propertyName) {
+        if (Array.isArray(parsedValue)) {
+            logger$2(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
-        setPropertyObj((draft) => {
-            draft[propertyName] = propertyValue;
+        const storageTransactionId = yield getStorageTransactionIdForSeedUid(propertyValue);
+        if (storageTransactionId) {
+            if (storageTransactionIdToContentUrl.has(storageTransactionId)) {
+                const contentUrl = storageTransactionIdToContentUrl.get(storageTransactionId);
+                sendBack({
+                    type: 'updateContext',
+                    renderValue: contentUrl,
+                });
+                sendBack({
+                    type: 'resolvingRelatedValueSuccess',
+                    resolvedDisplayValue: contentUrl,
+                    resolvedValue: storageTransactionId,
+                });
+                return true;
+            }
+            const contentUrl = yield convertTxIdToImageSrc(storageTransactionId);
+            if (contentUrl) {
+                seedUidToContentUrl.set(propertyValue, contentUrl);
+            }
+            sendBack({
+                type: 'updateContext',
+                renderValue: contentUrl,
+            });
+            sendBack({
+                type: 'resolvingRelatedValueSuccess',
+                resolvedDisplayValue: contentUrl,
+                resolvedValue: storageTransactionId,
+            });
+            return true;
+        }
+        const relationValueData = yield getRelationValueData(propertyValue);
+        if (relationValueData) {
+            const { refResolvedValue } = relationValueData;
+            const propertyValueFromDb = relationValueData.propertyValue;
+            // This handles a local-only relation value and resolves from the filesystem
+            if (refResolvedValue &&
+                propertyRecordSchema.dataType === 'Relation' &&
+                propertyValueFromDb.length === 10 &&
+                propertyRecordSchema.ref) {
+                if (refResolvedValueToContentUrl.has(refResolvedValue)) {
+                    const contentUrl = refResolvedValueToContentUrl.get(refResolvedValue);
+                    sendBack({
+                        type: 'updateContext',
+                        renderValue: contentUrl,
+                    });
+                    sendBack({
+                        type: 'resolvingRelatedValueSuccess',
+                        resolvedDisplayValue: contentUrl,
+                    });
+                    return true;
+                }
+                const fileExists = yield fs.promises.exists('/files/images/' + refResolvedValue);
+                if (fileExists) {
+                    const fileContents = yield fs.promises.readFile('/files/images/' + refResolvedValue);
+                    const fileHandler = new File([fileContents], refResolvedValue);
+                    const contentUrl = URL.createObjectURL(fileHandler);
+                    refResolvedValueToContentUrl.set(refResolvedValue, contentUrl);
+                    sendBack({
+                        type: 'updateContext',
+                        renderValue: contentUrl,
+                    });
+                    sendBack({
+                        type: 'resolvingRelatedValueSuccess',
+                        resolvedDisplayValue: contentUrl,
+                    });
+                    return true;
+                }
+            }
+            if (typeof propertyValueFromDb === 'string') {
+                // Check files for a filename that matches the propertyValue
+                if (propertyRecordSchema &&
+                    propertyRecordSchema.refValueType === 'ImageSrc') {
+                    let contentUrl;
+                    if (storageTransactionIdToContentUrl.has(propertyValueFromDb)) {
+                        contentUrl =
+                            storageTransactionIdToContentUrl.get(propertyValueFromDb);
+                    }
+                    if (!contentUrl) {
+                        const imageFileExists = yield fs.promises.exists(`/images/${propertyValue}`);
+                        if (imageFileExists) {
+                            const fileContents = yield fs.promises.readFile(`/images/${propertyValue}`);
+                            const fileHandler = new File([fileContents], propertyValue);
+                            contentUrl = URL.createObjectURL(fileHandler);
+                            storageTransactionIdToContentUrl.set(propertyValueFromDb, contentUrl);
+                        }
+                    }
+                    if (contentUrl) {
+                        sendBack({
+                            type: 'updateContext',
+                            renderValue: contentUrl,
+                        });
+                        sendBack({
+                            type: 'resolvingRelatedValueSuccess',
+                            resolvedDisplayValue: contentUrl,
+                        });
+                        return true;
+                    }
+                }
+            }
+        }
+    });
+    _resolveRelatedValue().then((success) => {
+        // if (success) {
+        //   sendBack({
+        //     type: 'resolvingRelatedValueDone',
+        //   })
+        // }
+        // return
+        sendBack({
+            type: 'resolvingRelatedValueDone',
         });
-    }, [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 eventKey = `storage.transaction.${initialValue}.contentUrl.response`
+//
+//   const contentUrlListener = async (event) => {
+//     console.log('[itemProperty] [constructor] contentUrlListener', event)
+//   }
+//
+//   eventEmitter.once(eventKey, contentUrlListener)
+//
+//   const ready = getArePropertyEventHandlersReady()
+//
+//   console.log('[itemProperty] [constructor] ready', ready)
+//
+//   eventEmitter.emit('storage.transaction.contentUrl.request', {
+//     storageTransactionId: initialValue,
+//   })
+// Related property values can either be seedUid or seedUid[]
+// let relatedSeedUid: string
+// let relatedSeedUids: string[]
+//
+// if (Array.isArray(propertyValue)) {
+//   relatedSeedUids = propertyValue
+// } else {
+//   relatedSeedUid = propertyValue
+// }
+//
+// if (relatedSeedUid) {
+//   console.log(
+//     `[property/actors] [resolveRelatedValue] seedUid: ${relatedSeedUid}`,
+//   )
+//   const latestVersionOfRelatedSeedQuery = await appDb.run(
+//     sql.raw(
+//       `
+//           SELECT local_id, uid, MAX(attestation_created_at)
+//           FROM versions
+//           WHERE seed_uid = '${relatedSeedUid}';
+//       `,
+//     ),
+//   )
+//   if (
+//     latestVersionOfRelatedSeedQuery &&
+//     latestVersionOfRelatedSeedQuery.rows &&
+//     latestVersionOfRelatedSeedQuery.rows.length > 0
+//   ) {
+//     const latestVersionOfRelatedSeed =
+//       latestVersionOfRelatedSeedQuery.rows[0]
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] latestVersionOfRelatedSeed',
+//       latestVersionOfRelatedSeed,
+//     )
+//     const storageIdQuery = await appDb.run(
+//       sql.raw(
+//         `
+//             SELECT property_value, MAX(attestation_created_at), ref_resolved_display_value, ref_resolved_value
+//             FROM metadata
+//             WHERE seed_uid = '${relatedSeedUid}'
+//               AND property_name = 'storageTransactionId';
+//         `,
+//       ),
+//     )
+//
+//     if (
+//       storageIdQuery &&
+//       storageIdQuery.rows &&
+//       storageIdQuery.rows.length > 0
+//     ) {
+//       const storageId = storageIdQuery.rows[0][0]
+//
+//       if (!storageId) {
+//         console.error(
+//           `storageId not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
+//         )
+//       }
+//
+//       const resolvedDisplayValue = storageIdQuery.rows[0][2]
+//       let resolvedValue = storageIdQuery.rows[0][3]
+//
+//       if (resolvedDisplayValue && resolvedValue) {
+//         sendBack({
+//           type: 'resolvingRelatedValueSuccess',
+//           resolvedDisplayValue,
+//           resolvedValue,
+//         })
+//         return
+//       }
+//
+//       console.log(
+//         '[property/actors] [resolveRelatedValue] storageId',
+//         storageId,
+//       )
+//
+//       const contentUrl = await convertTxIdToImageSrc(storageId)
+//
+//       if (!contentUrl) {
+//         throw new Error(
+//           `contentUrl not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
+//         )
+//       }
+//
+//       await appDb.run(
+//         sql.raw(
+//           `UPDATE metadata
+//            SET ref_resolved_display_value = '${contentUrl}',
+//                ref_resolved_value         = '${storageId}'
+//            WHERE seed_uid = '${relatedSeedUid}'
+//              AND property_name = 'storageTransactionId';
+//           `,
+//         ),
+//       )
+//
+//       sendBack({
+//         type: 'resolvingRelatedValueSuccess',
+//         resolvedDisplayValue: contentUrl,
+//         resolvedValue: storageId,
+//       })
+//     }
+//   }
+//
+//   const versionUidQuery = await appDb.run(
+//     sql.raw(
+//       `
+//           SELECT uid
+//           FROM versions
+//           WHERE seed_uid = '${relatedSeedUid}';
+//       `,
+//     ),
+//   )
+//
+//   if (
+//     versionUidQuery &&
+//     versionUidQuery.rows &&
+//     versionUidQuery.rows.length > 0
+//   ) {
+//     const versionUids = versionUidQuery.rows.map((row) => row[0])
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] versionUids',
+//       versionUids,
+//     )
+//     const { itemProperties } = await easClient.request(GET_PROPERTIES, {
+//       where: {
+//         refUID: {
+//           in: versionUids,
+//         },
+//         decodedDataJson: {
+//           contains: 'storage_transaction_id',
+//         },
+//       },
+//     })
+//
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] itemProperties',
+//       itemProperties,
+//     )
+//
+//     if (itemProperties && itemProperties.length > 0) {
+//       await savePropertiesToDb(itemProperties)
+//     }
+//   }
+// }
 
-const useDeleteItem = () => {
-    const [isDeletingItem, setIsDeletingItem] = useState(false);
-    const destroy = useCallback((item) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!item) {
-            return;
-        }
-        setIsDeletingItem(true);
-        const { modelName } = item.getService().getSnapshot().context;
-        yield deleteItem({ seedLocalId: item.seedLocalId });
-        eventEmitter.emit('item.requestAll', { modelName });
-        setIsDeletingItem(false);
-    }), [isDeletingItem]);
-    useEffect(() => { }, []);
-    return {
-        deleteItem: destroy,
-        isDeletingItem,
-    };
-};
-
-const logger$1 = debug('app:services:events');
-const handleServiceSaveState = (event) => {
-    const { state, serviceId } = event;
-    logger$1(`[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];
-    if (!service) {
-        console.log(`[saveServiceHandler] service not found: ${nameOfService}`);
-        return;
+const updateMetadata = (metadataValues) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    const { localId } = metadataValues, rest = __rest(metadataValues, ["localId"]);
+    if (!localId) {
+        throw new Error('No localId provided to updateMetadata');
     }
-    yield saveAppState(`snapshot__${modelName}`, JSON.stringify(service.getPersistedSnapshot()));
+    yield appDb.update(metadata).set(rest).where(eq(metadata.localId, localId));
 });
 
-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);
+const logger$1 = debug('app:property:actors:hydrateFromDb');
+const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
+    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyValue, propertyRecordSchema, itemModelName, } = context;
+    let propertyName = propertyNameRaw;
+    if (propertyRecordSchema &&
+        propertyRecordSchema.ref &&
+        propertyRecordSchema.dataType === 'Relation' &&
+        !propertyNameRaw.endsWith('Id')) {
+        propertyName = propertyNameRaw + 'Id';
+    }
+    if (propertyRecordSchema &&
+        propertyRecordSchema.ref &&
+        propertyRecordSchema.dataType === 'List' &&
+        !propertyNameRaw.endsWith('Ids')) {
+        propertyName = propertyNameRaw + 'Ids';
+    }
+    const _hydrateFromDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        const appDb = getAppDb();
+        const isRelation = propertyRecordSchema &&
+            propertyRecordSchema.ref &&
+            propertyRecordSchema.dataType === 'Relation';
+        const whereClauses = [];
+        if (isRelation) {
+            let missingPropertyNameVariant;
+            if (propertyName.endsWith('Id')) {
+                missingPropertyNameVariant = propertyName.slice(0, -2);
+            }
+            if (!propertyName.endsWith('Id')) {
+                missingPropertyNameVariant = propertyName + 'Id';
+            }
+            if (missingPropertyNameVariant) {
+                whereClauses.push(or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, missingPropertyNameVariant)));
+            }
+            if (!missingPropertyNameVariant) {
+                whereClauses.push(eq(metadata.propertyName, propertyName));
+            }
         }
-        setupFsListeners();
-        setupAllItemsEventHandlers();
-        setupServicesEventHandlers();
-        setupServiceHandlers();
-        if (areFsListenersReady()) {
-            eventEmitter.emit('fs.init');
+        else {
+            whereClauses.push(eq(metadata.propertyName, propertyName));
         }
-        if (!areFsListenersReady()) {
-            console.error('fs listeners not ready during init');
+        if (seedUid) {
+            whereClauses.push(eq(metadata.seedUid, seedUid));
         }
-        globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-wQXee2fb.js').then(({ models }) => {
-            for (const [key, value] of Object.entries(models)) {
-                setModel(key, value);
+        if (seedLocalId) {
+            whereClauses.push(eq(metadata.seedLocalId, seedLocalId));
+        }
+        const rows = yield appDb
+            .select()
+            .from(metadata)
+            .where(and(...whereClauses))
+            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'));
+        if (!rows || !rows.length) {
+            return;
+        }
+        const firstRow = rows[0];
+        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, localStorageDir, } = firstRow;
+        let { refResolvedDisplayValue, refResolvedValue } = firstRow;
+        let propertyValueProcessed = propertyValueFromDb;
+        if (propertyName && !propertyNameFromDb) {
+            logger$1(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
+        }
+        if (propertyName &&
+            propertyNameFromDb &&
+            !propertyNameFromDb.includes(propertyName) &&
+            !propertyName.includes(propertyNameFromDb) &&
+            propertyNameFromDb !== propertyName) {
+            logger$1(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
+        }
+        if (propertyValue && propertyValueFromDb !== propertyValue) {
+            logger$1(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
+        }
+        if (seedLocalIdFromDb !== seedLocalId) {
+            logger$1(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
+        }
+        if (seedUidFromDb !== seedUid) {
+            logger$1(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
+        }
+        if (propertyRecordSchema &&
+            propertyRecordSchema.refValueType === 'ImageSrc') {
+            let shouldReadFromFile = true;
+            if (refResolvedValue &&
+                refResolvedDisplayValue &&
+                refResolvedDisplayValue.includes('http')) {
+                try {
+                    const response = yield fetch(refResolvedDisplayValue, {
+                        method: 'HEAD',
+                    });
+                    // Check if the status is in the 200-299 range
+                    if (response.ok) {
+                        shouldReadFromFile = false;
+                    }
+                }
+                catch (error) {
+                    shouldReadFromFile = true;
+                }
             }
-        });
-    },
-    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);
+            if (shouldReadFromFile) {
+                let dir = localStorageDir;
+                if (!dir &&
+                    propertyRecordSchema &&
+                    propertyRecordSchema.refValueType === 'ImageSrc') {
+                    dir = 'images';
                 }
-            });
-            globalService.send({ type: 'getSeed' });
-            subscription.unsubscribe();
+                dir = dir.replace(/^\//, '');
+                if (!refResolvedValue &&
+                    propertyValueFromDb &&
+                    propertyValueFromDb.length === 66) {
+                    const storageTransactionQuery = yield appDb
+                        .select({
+                        propertyValue: metadata.propertyValue,
+                    })
+                        .from(metadata)
+                        .where(and(eq(metadata.seedUid, propertyValueFromDb), eq(metadata.propertyName, 'storageTransactionId')));
+                    if (storageTransactionQuery && storageTransactionQuery.length > 0) {
+                        const row = storageTransactionQuery[0];
+                        refResolvedValue = row.propertyValue;
+                        console.log('storageTransactionId', refResolvedValue);
+                        yield updateMetadata({
+                            localId,
+                            refResolvedValue,
+                            localStorageDir: '/images',
+                        });
+                    }
+                }
+                const dirPath = `/files/${dir}`;
+                const files = yield fs.promises.readdir(dirPath);
+                const matchingFiles = files.filter((file) => {
+                    return path.basename(file).includes(refResolvedValue);
+                });
+                let fileExists = false;
+                let filename;
+                let filePath;
+                if (matchingFiles && matchingFiles.length > 0) {
+                    fileExists = true;
+                    filename = matchingFiles[0];
+                    filePath = `/files/${dir}/${filename}`;
+                }
+                if (fileExists && filename && filePath) {
+                    const fileContents = yield fs.promises.readFile(filePath);
+                    const fileHandler = new File([fileContents], filename);
+                    refResolvedDisplayValue = URL.createObjectURL(fileHandler);
+                    yield updateMetadata({
+                        localId,
+                        refResolvedValue: filename,
+                    });
+                }
+            }
+        }
+        if (propertyRecordSchema &&
+            propertyRecordSchema.dataType === 'List' &&
+            propertyRecordSchema.ref &&
+            typeof propertyValueFromDb === 'string') {
+            propertyValueProcessed = propertyValueFromDb.split(',');
+        }
+        sendBack({
+            type: 'updateContext',
+            localId,
+            uid,
+            propertyValue: propertyValueProcessed,
+            seedLocalId: seedLocalIdFromDb,
+            seedUid: seedUidFromDb,
+            versionLocalId: versionLocalIdFromDb,
+            versionUid: versionUidFromDb,
+            schemaUid: schemaUidFromDb,
+            refValueType,
+            localStorageDir,
+            resolvedValue: refResolvedValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
+            renderValue: refResolvedDisplayValue,
+            populatedFromDb: true,
         });
-    }),
-    getModel: (modelName) => {
-        return getModel(modelName);
-    },
-    getModels: () => {
-        return getModels();
-    },
-    getModelNames: () => {
-        return getModelNames();
-    },
-};
+        if (propertyRecordSchema &&
+            propertyRecordSchema.storageType &&
+            propertyRecordSchema.storageType === 'ItemStorage') {
+            const { Item } = yield import('./index-DyEsLJAK.js');
+            const item = yield Item.find({
+                seedLocalId,
+                modelName: itemModelName,
+            });
+            if (item) {
+                const filePath = `/files/${localStorageDir}/${refResolvedValue}`;
+                const exists = yield fs.promises.exists(filePath);
+                if (!exists) {
+                    return;
+                }
+                const renderValue = yield fs.promises.readFile(filePath, 'utf8');
+                const property = item.properties[propertyName];
+                property.getService().send({ type: 'updateContext', renderValue });
+                return;
+            }
+        }
+    });
+    _hydrateFromDb().then(() => {
+        sendBack({ type: 'hydrateFromDbSuccess' });
+    });
+});
 
 const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ localId, seedLocalId, uid, }) {
     const appDb = getAppDb();
@@ -7016,8 +7202,10 @@ const fetchImage = (url) => __awaiter(void 0, void 0, void 0, function* () {
     }
     return base64;
 });
+let imageSchemaUid;
 const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, schemaUid, } = context;
+    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, } = context;
+    let { schemaUid } = context;
     let newValue;
     if (event) {
         newValue = event.newValue;
@@ -7035,6 +7223,9 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
         let fileData;
         let mimeType;
         let fileName;
+        if (!imageSchemaUid) {
+            imageSchemaUid = yield getSchemaUidForModel('Image');
+        }
         if (typeof newValue === 'string') {
             newValueType = getDataTypeFromString(newValue);
         }
@@ -7081,6 +7272,9 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
             yield fs.promises.writeFile(filePath, fileData);
         }
         const refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
+        if (!schemaUid) {
+            schemaUid = getSchemaUidForSchemaDefinition(propertyName);
+        }
         if (!localId) {
             yield createMetadata({
                 propertyName,
@@ -7092,6 +7286,8 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 modelName: itemModelName,
                 schemaUid,
                 refSeedType: 'image',
+                refModelUid: imageSchemaUid,
+                refSchemaUid: imageSchemaUid,
                 refResolvedDisplayValue,
                 refResolvedValue: fileName,
                 localStorageDir: '/images',
@@ -7110,6 +7306,8 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
                 refSeedType: 'image',
                 refResolvedDisplayValue,
                 refResolvedValue: fileName,
+                refModelUid: imageSchemaUid,
+                refSchemaUid: imageSchemaUid,
                 localStorageDir: '/images',
                 easDataType: 'bytes32',
             });
@@ -7118,9 +7316,12 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
             type: 'updateContext',
             propertyValue: newImageSeedLocalId,
             refSeedType: 'image',
+            refSchemaUid: imageSchemaUid,
             renderValue: refResolvedDisplayValue,
             resolvedDisplayValue: refResolvedDisplayValue,
             resolvedValue: fileName,
+            localStorageDir: '/images',
+            easDataType: 'bytes32',
         });
     });
     _saveImageSrc().then(() => {
@@ -7326,7 +7527,7 @@ const propertyMachine = setup({
     actors: {
         waitForDb: waitForDb$1,
         hydrateFromDb,
-        initialize: initialize$3,
+        initialize,
         resolveRelatedValue,
         resolveRemoteStorage,
         analyzeInput,
@@ -7651,4 +7852,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--nvTinP_.js.map
+//# sourceMappingURL=index-CvfKxmFw.js.map