@seedprotocol/sdk 0.1.8 → 0.1.11

package/dist/{index-Dg73YrcZ.js → index-Dd2ggBQg.js}

@@ -3,7 +3,7 @@ import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, createActor, waitFor, setup, assign, emit } from 'xstate';
 import { fs, configureSingle } from '@zenfs/core';
-import { sql, relations, eq, isNull, and } from 'drizzle-orm';
+import { sql, count, max, eq, and, or, isNull, relations } from 'drizzle-orm';
 import { drizzle } from 'drizzle-orm/sqlite-proxy';
 import debug from 'debug';
 import 'dayjs';
@@ -692,6 +692,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyName, storageTransactionId, seedLocalId } = context;
     if (isRelation) {
         sendBack({ type: 'isRelatedProperty' });
+        sendBack({ type: 'initializeSuccess' });
         return;
     }
     if (!isRelation) {
@@ -814,7 +815,7 @@ const parseEasRelationPropertyName = (easPropertyName) => {
     };
 };
 
-sqliteTable('seeds', {
+const seeds = sqliteTable('seeds', {
     localId: text('local_id').unique(),
     uid: text('uid'),
     schemaUid: text('schema_uid'),
@@ -826,7 +827,7 @@ sqliteTable('seeds', {
     _markedForDeletion: int('_marked_for_deletion'),
 });
 
-sqliteTable('versions', {
+const versions = sqliteTable('versions', {
     localId: text('local_id').unique(),
     uid: text('uid'),
     seedLocalId: text('seed_local_id'),
@@ -839,7 +840,7 @@ sqliteTable('versions', {
     attestationRaw: text('attestation_raw'),
 });
 
-sqliteTable('metadata', {
+const metadata = sqliteTable('metadata', {
     localId: text('local_id').unique(),
     uid: text('uid'),
     propertyName: text('property_name'),
@@ -871,38 +872,21 @@ const appState = sqliteTable('appState', {
 
 const getItemsData = (modelName) => __awaiter(void 0, void 0, void 0, function* () {
     const appDb = getAppDb();
-    const itemsFromDbQuery = yield appDb.run(sql.raw(`SELECT s.local_id,
-              s.uid,
-              s.schema_uid,
-              s.attestation_created_at,
-              s.created_at,
-              COUNT(v.local_id)             as versions_count,
-              MAX(v.attestation_created_at) as last_version_published_at,
-              MAX(v.created_at)             as last_local_update_at
-       FROM seeds s
-                JOIN versions v ON s.local_id = v.seed_local_id
-       WHERE s.type = '${modelName.toLowerCase()}'
-         AND (_marked_for_deletion IS NULL
-           OR _marked_for_deletion = 0)
-       GROUP BY s.local_id;`));
-    if (!itemsFromDbQuery ||
-        !itemsFromDbQuery.rows ||
-        itemsFromDbQuery.rows.length === 0) {
-        return [];
-    }
-    const itemsData = [];
-    for (const itemDbValues of itemsFromDbQuery.rows) {
-        itemsData.push({
-            seedLocalId: itemDbValues[0],
-            seedUid: itemDbValues[1],
-            schemaUid: itemDbValues[2],
-            attestationCreatedAt: itemDbValues[3],
-            createdAt: itemDbValues[4],
-            versionsCount: itemDbValues[5],
-            lastVersionPublishedAt: itemDbValues[6],
-            lastLocalUpdateAt: itemDbValues[7],
-        });
-    }
+    const itemsData = (yield appDb
+        .select({
+        seedLocalId: seeds.localId,
+        seedUid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        modelName: sql `${modelName}`,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        versionsCount: count(versions.localId),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt),
+        lastLocalUpdateAt: max(versions.createdAt),
+    })
+        .from(seeds)
+        .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
+        .where(and(eq(seeds.type, modelName.toLowerCase()), or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0))))
+        .groupBy(seeds.localId));
     return itemsData;
 });
 
@@ -951,36 +935,37 @@ const getPropertyData = (propertyName, seedLocalId) => __awaiter(void 0, void 0,
         updatedAt: row[12],
     };
 });
+const seedUidToStorageTransactionId = new Map();
 const getStorageTransactionIdForSeedUid = (seedUid) => __awaiter(void 0, void 0, void 0, function* () {
-    const storageTransactionIdStatement = `SELECT property_value,
-                                                MAX(attestation_created_at),
-                                                ref_resolved_display_value,
-                                                ref_resolved_value,
-                                                ref_seed_type,
-                                                eas_data_type
-                                         FROM metadata
-                                         WHERE (
-                                                   seed_uid = '${seedUid}'
-                                                       AND property_name = 'storageTransactionId'
-                                                   );
-  `;
-    const { rows } = yield runQueryForStatement(storageTransactionIdStatement);
-    if (!rows || rows.length === 0 || !rows[0][0]) {
+    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;
     }
-    return rows[0][0];
+    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
+    return results[0].storageTransactionId;
 });
 const getRelationValueData = (propertyValue) => __awaiter(void 0, void 0, void 0, function* () {
-    const propertyValueStatement = `SELECT property_value,
-                                         MAX(attestation_created_at),
-                                         ref_resolved_display_value,
-                                         ref_resolved_value,
-                                         ref_seed_type,
-                                         eas_data_type
-                                  FROM metadata
-                                  WHERE property_value = '${propertyValue}';
-  `;
-    const { rows } = yield runQueryForStatement(propertyValueStatement);
+    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;
     }
@@ -1029,16 +1014,50 @@ const getExistingItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ see
     return existingItem;
 });
 
+const storageTransactionIdToContentUrl = new Map();
+const refResolvedValueToContentUrl = new Map();
+const seedUidToContentUrl = new Map();
 const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, seedLocalId, schemaUid, } = context;
-    getAppDb();
     const _resolveRelatedValue = () => __awaiter(void 0, void 0, void 0, function* () {
         if (!propertyValue || !isRelation) {
             return;
         }
+        if (seedUidToContentUrl.has(propertyValue)) {
+            const contentUrl = seedUidToContentUrl.get(propertyValue);
+            sendBack({
+                type: 'updateRenderValue',
+                renderValue: contentUrl,
+            });
+            sendBack({
+                type: 'resolvingRelatedValueSuccess',
+                resolvedDisplayValue: contentUrl,
+            });
+            return true;
+        }
+        if (Array.isArray(propertyValue)) {
+            // TODO: Handle array of seedUids
+            return;
+        }
         const storageTransactionId = yield getStorageTransactionIdForSeedUid(propertyValue);
         if (storageTransactionId) {
+            if (storageTransactionIdToContentUrl.has(storageTransactionId)) {
+                const contentUrl = storageTransactionIdToContentUrl.get(storageTransactionId);
+                sendBack({
+                    type: 'updateRenderValue',
+                    renderValue: contentUrl,
+                });
+                sendBack({
+                    type: 'resolvingRelatedValueSuccess',
+                    resolvedDisplayValue: contentUrl,
+                    resolvedValue: storageTransactionId,
+                });
+                return true;
+            }
             const contentUrl = yield convertTxIdToImageSrc(storageTransactionId);
+            if (contentUrl) {
+                seedUidToContentUrl.set(propertyValue, contentUrl);
+            }
             sendBack({
                 type: 'updateRenderValue',
                 renderValue: contentUrl,
@@ -1052,20 +1071,31 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
         }
         const relationValueData = yield getRelationValueData(propertyValue);
         if (relationValueData) {
-            const propertyValueFromDb = relationValueData[0];
-            const refResolvedValue = relationValueData[3];
-            relationValueData[4];
-            relationValueData[5];
+            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: 'updateRenderValue',
+                        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: 'updateRenderValue',
                         renderValue: contentUrl,
@@ -1080,11 +1110,21 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             if (typeof propertyValueFromDb === 'string') {
                 // Check files for a filename that matches the propertyValue
                 if (propertyRecordSchema.dataType === 'ImageSrc') {
-                    const imageFileExists = yield fs.promises.exists(`/images/${propertyValue}`);
-                    const fileContents = yield fs.promises.readFile(`/images/${propertyValue}`);
-                    const fileHandler = new File([fileContents], propertyValue);
-                    const contentUrl = URL.createObjectURL(fileHandler);
-                    if (imageFileExists) {
+                    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: 'updateRenderValue',
                             renderValue: contentUrl,
@@ -1100,12 +1140,15 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
         }
     });
     _resolveRelatedValue().then((success) => {
-        if (!success) {
-            sendBack({
-                type: 'resolvingRelatedValueDone',
-            });
-        }
-        return;
+        // if (success) {
+        //   sendBack({
+        //     type: 'resolvingRelatedValueDone',
+        //   })
+        // }
+        // return
+        sendBack({
+            type: 'resolvingRelatedValueDone',
+        });
     });
 });
 //   const eventKey = `storage.transaction.${initialValue}.contentUrl.response`
@@ -1528,164 +1571,6 @@ const getAddressesFromDb = () => __awaiter(void 0, void 0, void 0, function* ()
     return JSON.parse(addressArrayString);
 });
 
-const logger$c = 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 db = getAppDb();
-        let hydrateQuery;
-        let safeValue = propertyValue;
-        let propertyNameQueryString = `property_name = '${propertyName}'`;
-        if (safeValue && typeof propertyValue === 'string') {
-            safeValue = escapeSqliteString(propertyValue);
-        }
-        if (propertyRecordSchema &&
-            propertyRecordSchema.ref &&
-            propertyRecordSchema.dataType === 'Relation') {
-            let missingPropertyNameVariant;
-            if (propertyName.endsWith('Id')) {
-                missingPropertyNameVariant = propertyName.slice(0, -2);
-            }
-            if (!propertyName.endsWith('Id')) {
-                missingPropertyNameVariant = propertyName + 'Id';
-            }
-            propertyNameQueryString += ` OR property_name = '${missingPropertyNameVariant}'`;
-        }
-        if (seedUid && !seedLocalId) {
-            hydrateQuery = yield db.run(sql.raw(`SELECT local_id,
-                    uid,
-                    property_name,
-                    property_value,
-                    seed_local_id,
-                    seed_uid,
-                    schema_uid,
-                    ref_resolved_value,
-                    ref_resolved_display_value
-             FROM metadata
-             WHERE seed_uid = '${seedUid}'
-               AND (${propertyNameQueryString})
-             ORDER BY COALESCE(attestation_created_at, created_at) DESC;
-            `));
-        }
-        if (seedUid && seedLocalId) {
-            hydrateQuery = yield db.run(sql.raw(`SELECT local_id,
-                    uid,
-                    property_name,
-                    property_value,
-                    seed_local_id,
-                    seed_uid,
-                    schema_uid,
-                    ref_resolved_value,
-                    ref_resolved_display_value
-             FROM metadata
-             WHERE seed_local_id = '${seedLocalId}'
-               AND (${propertyNameQueryString})
-               AND seed_uid = '${seedUid}'
-             ORDER BY COALESCE(attestation_created_at, created_at) DESC;
-            `));
-        }
-        if (!seedUid && seedLocalId) {
-            hydrateQuery = yield db.run(sql.raw(`SELECT local_id,
-                    uid,
-                    property_name,
-                    property_value,
-                    seed_local_id,
-                    seed_uid,
-                    schema_uid,
-                    ref_resolved_value,
-                    ref_resolved_display_value
-             FROM metadata
-             WHERE seed_local_id = '${seedLocalId}'
-               AND (${propertyNameQueryString})
-             ORDER BY COALESCE(attestation_created_at, created_at) DESC;
-            `));
-        }
-        if (hydrateQuery && hydrateQuery.rows && hydrateQuery.rows.length > 0) {
-            const firstRow = hydrateQuery.rows[0];
-            const localId = firstRow[0];
-            const uid = firstRow[1];
-            const propertyNameFromDb = firstRow[2];
-            const propertyValueFromDb = firstRow[3];
-            const seedLocalIdFromDb = firstRow[4];
-            const seedUidFromDb = firstRow[5];
-            const schemaUidFromDb = firstRow[6];
-            const refResolvedValue = firstRow[7];
-            const refResolvedDisplayValue = firstRow[8];
-            if (propertyNameFromDb !== propertyName) {
-                logger$c(`Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`);
-            }
-            if (propertyValueFromDb !== propertyValue) {
-                logger$c(`Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`);
-            }
-            if (seedLocalIdFromDb !== seedLocalId) {
-                logger$c(`Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`);
-            }
-            if (seedUidFromDb !== seedUid) {
-                logger$c(`Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`);
-            }
-            sendBack({
-                type: 'updateContext',
-                localId,
-                uid,
-                propertyName: propertyNameFromDb,
-                propertyValue: propertyValueFromDb,
-                seedLocalId: seedLocalIdFromDb,
-                seedUid: seedUidFromDb,
-                schemaUid: schemaUidFromDb,
-                resolveValue: refResolvedValue,
-                resolveDisplayValue: refResolvedDisplayValue,
-                renderValue: refResolvedDisplayValue,
-            });
-            if (propertyNameFromDb === 'storageTransactionId') {
-                const { Item } = yield import('./index-BeywvMUe.js');
-                const item = yield Item.find({
-                    seedLocalId,
-                    modelName: itemModelName,
-                });
-                if (item) {
-                    for (const [propertyName, property] of Object.entries(item.properties)) {
-                        if (propertyName === 'html' &&
-                            propertyValueFromDb &&
-                            propertyValueFromDb.length === 43) {
-                            const htmlFilePath = `/files/html/${propertyValueFromDb}.html`;
-                            const exists = yield fs.promises.exists(htmlFilePath);
-                            if (!exists) {
-                                logger$c(`HTML file does not exist for Property.${localId} at ${htmlFilePath}`);
-                                return;
-                            }
-                            const renderValue = yield fs.promises
-                                .readFile(htmlFilePath, 'utf8')
-                                .catch((error) => {
-                                logger$c('Error reading html file', error);
-                            });
-                            property
-                                .getService()
-                                .send({ type: 'updateRenderValue', renderValue });
-                            return;
-                        }
-                    }
-                }
-            }
-        }
-    });
-    _hydrateFromDb().then(() => {
-        sendBack({ type: 'hydrateFromDbSuccess' });
-    });
-});
-
 const eventEmitter = new EventEmitter();
 
 const APP_DB_CONFIG = 'browser.app.db.config.ts';
@@ -1732,7 +1617,7 @@ const internalPropertyNames = [
 ];
 
 var _a$2;
-const logger$b = debug('app:property:class');
+const logger$c = debug('app:property:class');
 const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
@@ -1780,7 +1665,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$b('List property value is not JSON', e);
+                            logger$c('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -1834,47 +1719,50 @@ class ItemProperty {
             }
             if (skipTransform && !this._alias) ;
             this._subject.next(renderValue);
+            // eventEmitter.emit(
+            //   `item.${itemModelName},${seedUid || seedLocalId}.update`,
+            // )
             // this._lastRenderedValue = renderValue
         });
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$b(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$c(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, uid } = props;
         if (seedLocalId && propertyName) {
             const cacheKey = ItemProperty.cacheKey(seedLocalId, propertyName);
-            if (this.instanceCache.has(cacheKey)) {
-                const { instance, refCount } = this.instanceCache.get(cacheKey);
-                this.instanceCache.set(cacheKey, {
+            if (ItemProperty.instanceCache.has(cacheKey)) {
+                const { instance, refCount } = ItemProperty.instanceCache.get(cacheKey);
+                ItemProperty.instanceCache.set(cacheKey, {
                     instance,
                     refCount: refCount + 1,
                 });
-                if (instance.status === 'idle') {
-                    instance.getService().send({ type: 'refresh' });
-                }
-                if (seedLocalId === 'R4RYj2pYIQ' && propertyName === 'html') {
-                    logger$b('[property/class] [create] [R4RYj2pYIQ] returning cached instance', instance.getService().getSnapshot().context);
-                }
                 return instance;
             }
+            if (!ItemProperty.instanceCache.has(cacheKey)) {
+                const newInstance = new ItemProperty(props);
+                ItemProperty.instanceCache.set(cacheKey, {
+                    instance: newInstance,
+                    refCount: 1,
+                });
+                return newInstance;
+            }
         }
         if (uid) {
             if (this.instanceCache.has(uid)) {
                 const { instance, refCount } = this.instanceCache.get(uid);
                 this.instanceCache.set(uid, { instance, refCount: refCount + 1 });
-                if (seedLocalId === 'R4RYj2pYIQ' && propertyName === 'html') {
-                    logger$b('[property/class] [create] [uid] [R4RYj2pYIQ] returning cached instance', instance.getService().getSnapshot().context);
-                }
                 return instance;
             }
+            if (!this.instanceCache.has(uid)) {
+                const newInstance = new ItemProperty(props);
+                this.instanceCache.set(uid, { instance: newInstance, refCount: 1 });
+                return newInstance;
+            }
         }
-        const newInstance = new ItemProperty(props);
-        if (props.seedLocalId === 'R4RYj2pYIQ' && propertyName === 'html') {
-            logger$b('[property/class] [create] [R4RYj2pYIQ] returning new instance', props, newInstance.getService().getSnapshot().context);
-        }
-        return newInstance;
+        return new ItemProperty(props);
     }
     static find(_b) {
         return __awaiter(this, arguments, void 0, function* ({ propertyName, seedLocalId, }) {
@@ -1975,7 +1863,7 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$b(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$c(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
@@ -2069,7 +1957,7 @@ const getContentUrlFromPath = (path) => __awaiter(void 0, void 0, void 0, functi
     return URL.createObjectURL(fileHandler);
 });
 
-const logger$a = debug('app:global:actors');
+const logger$b = debug('app:global:actors');
 const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints } = context;
     const { addresses } = event;
@@ -2090,7 +1978,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$a('[sdk] [internal] snapshot', snapshot);
+                    logger$b('[sdk] [internal] snapshot', snapshot);
                     if (snapshot.value === 'ready') {
                         resolve();
                     }
@@ -2099,10 +1987,10 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
             });
         });
         _initFileSystem().then(() => {
-            logger$a('[global/actors] File system initialized');
+            logger$b('[global/actors] File system initialized');
         });
         _initInternal().then(() => {
-            logger$a('[global/actors] Internal initialized');
+            logger$b('[global/actors] Internal initialized');
             sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
             internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
         });
@@ -2123,12 +2011,12 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-CxqrGPwe.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-Dg9Q0kx4.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$a('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$b('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = yield sdkConfigDb
                 .select()
@@ -2138,7 +2026,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 yield sdkConfigDb.insert(models).values({
                     name: modelName,
                 });
-                logger$a('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$b('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = yield sdkConfigDb
                     .select({
                     id: models.id,
@@ -2222,7 +2110,7 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$a('[service/actor] [getSchemaForModel] model:', model);
+    logger$b('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
@@ -2276,7 +2164,7 @@ class SqliteConnectionManager {
     }
 }
 
-const logger$9 = debug('app:services:internal:helpers');
+const logger$a = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -2352,7 +2240,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$9(`[Error] Failed to download file from ${url}:`, error);
+        logger$a(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 });
@@ -2390,7 +2278,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$9('[syncDbFiles] Files synced!');
+    logger$a('[syncDbFiles] Files synced!');
 });
 
 const uploadBinaryData = fromCallback(({ sendBack, receive, input }) => { });
@@ -2700,7 +2588,7 @@ const getArweave = () => {
     });
 };
 
-const logger$8 = debug('app:files:download');
+const logger$9 = 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 });
@@ -2770,7 +2658,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$8(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$9(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 yield writeAppState(seedDb, 'excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -2784,7 +2672,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 console.error(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`, error);
             });
             if (!dataString) {
-                logger$8(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
+                logger$9(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
             let contentType = identifyString(dataString);
             if (contentType !== 'json' &&
@@ -2792,7 +2680,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 contentType !== 'html') {
                 const possibleImageType = getImageDataType(dataString);
                 if (!possibleImageType) {
-                    logger$8(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    logger$9(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
                 }
                 contentType = possibleImageType;
@@ -2855,7 +2743,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             }
         }
         catch (error) {
-            logger$8(error);
+            logger$9(error);
         }
     }
 });
@@ -2901,7 +2789,7 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$7 = debug('app:internal:actors');
+const logger$8 = debug('app:internal:actors');
 let sqliteWasmClient;
 let manager;
 const validateInput = fromCallback(({ sendBack, input: { event } }) => {
@@ -2954,12 +2842,12 @@ const prepareDb = fromCallback(({ sendBack, input: { event, context } }) => {
 });
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, seedDbService, appDbService, sdkDbService } = context;
-    logger$7('[internal/actors] [configureFs] Configuring FS');
+    logger$8('[internal/actors] [configureFs] Configuring FS');
     const services = [seedDbService, appDbService, sdkDbService];
     const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$7('[internal/actors] [configureFs] calling _configureFs');
-        logger$7('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$7('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$8('[internal/actors] [configureFs] calling _configureFs');
+        logger$8('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$8('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         yield waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -2991,7 +2879,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
             //   }, 200)
             // })
         })));
-        logger$7('[internal/actors] [configureFs] fs configured!');
+        logger$8('[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
@@ -3077,14 +2965,14 @@ const saveConfig = fromCallback(({ sendBack, receive, input: { context } }) => {
                 },
                 setWhere: sql `key = 'addresses'`,
             });
-            logger$7('[sdk] [internal/actors] Should be done saving');
+            logger$8('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     });
     _saveConfig().then(() => {
-        logger$7('[sdk] [internal/actors] Successfully saved config');
+        logger$8('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
@@ -3109,7 +2997,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$7('[sdk] [internal/actors] Successfully loaded app DB');
+        logger$8('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -3119,7 +3007,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
 });
 const loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
     const { sdkDbService } = context;
-    logger$7('[sdk] [internal/actors] Loading SDK DB');
+    logger$8('[sdk] [internal/actors] Loading SDK DB');
     let subscription;
     const _loadSdkDb = () => __awaiter(void 0, void 0, void 0, function* () {
         return new Promise((resolve) => {
@@ -3142,7 +3030,7 @@ const loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadSdkDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_SDK_DB_SUCCESS });
-        logger$7('[sdk] [internal/actors] Successfully loaded SDK DB');
+        logger$8('[sdk] [internal/actors] Successfully loaded SDK DB');
     });
     return () => {
         if (subscription) {
@@ -3151,7 +3039,7 @@ const loadSdkDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$6 = debug('app:services:db:machine');
+const logger$7 = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -3172,7 +3060,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$6('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$7('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -3181,8 +3069,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$6('[db/machine] updateHasFiles event:', event);
-                    logger$6('[db/machine] updateHasFiles context:', context);
+                    logger$7('[db/machine] updateHasFiles event:', event);
+                    logger$7('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -3303,7 +3191,7 @@ const dbMachine = setup({
     },
 });
 
-const logger$5 = debug('app:services:internal:machine');
+const logger$6 = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
@@ -3465,7 +3353,7 @@ const internalMachine = setup({
                                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                                     target: 'appDbLoaded',
                                     actions: () => {
-                                        logger$5('[sdk] [internal/index] App DB loaded!');
+                                        logger$6('[sdk] [internal/index] App DB loaded!');
                                     },
                                 },
                             },
@@ -3477,7 +3365,7 @@ const internalMachine = setup({
                         appDbLoaded: {
                             type: 'final',
                             entry: () => {
-                                logger$5('[sdk] [internal/index] Entered appDbLoaded!');
+                                logger$6('[sdk] [internal/index] Entered appDbLoaded!');
                             },
                         },
                     },
@@ -3490,7 +3378,7 @@ const internalMachine = setup({
                                 [INTERNAL_LOADING_SDK_DB_SUCCESS]: {
                                     target: 'sdkConfigDbLoaded',
                                     actions: () => {
-                                        logger$5('[sdk] [internal/index] SDK Config DB loaded!');
+                                        logger$6('[sdk] [internal/index] SDK Config DB loaded!');
                                     },
                                 },
                             },
@@ -3502,7 +3390,7 @@ const internalMachine = setup({
                         sdkConfigDbLoaded: {
                             type: 'final',
                             entry: () => {
-                                logger$5('[sdk] [internal/index] Entered sdkConfigDbLoaded!');
+                                logger$6('[sdk] [internal/index] Entered sdkConfigDbLoaded!');
                             },
                         },
                     },
@@ -3511,7 +3399,7 @@ const internalMachine = setup({
             onDone: {
                 target: 'ready',
                 actions: () => {
-                    logger$5('[sdk] [internal/index] All DBs loaded! Should be headed to ready');
+                    logger$6('[sdk] [internal/index] All DBs loaded! Should be headed to ready');
                     eventEmitter.emit('allDbsLoaded');
                 },
             },
@@ -3523,7 +3411,7 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$5('[sdk] [internal/index] Ready!');
+                logger$6('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -3538,7 +3426,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$5('[sdk] [internal/index] Error!');
+                logger$6('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -3745,7 +3633,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$4 = debug('app:allItemsActors:fetchSeeds');
+const logger$5 = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -3755,7 +3643,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$4(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$5(`[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); }),
@@ -4243,11 +4131,11 @@ const globalMachine = setup({
                         (_a) => __awaiter(void 0, [_a], void 0, function* ({ context }) {
                             let SeedClass;
                             if (context.environment === 'node') {
-                                const { SeedNode } = yield import('./seed-CsQB9h6Q.js');
+                                const { SeedNode } = yield import('./seed-T0Gph_yX.js');
                                 SeedClass = SeedNode;
                             }
                             else {
-                                const { SeedBrowser } = yield import('./seed-Cqa2atpR.js');
+                                const { SeedBrowser } = yield import('./seed-CM9XY9k9.js');
                                 SeedClass = SeedBrowser;
                             }
                             return SeedClass;
@@ -5338,7 +5226,7 @@ const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoc
     };
 });
 
-const logger$3 = debug('app:db:queries:getItem');
+const logger$4 = debug('app:db:queries:getItem');
 const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, seedUid, }) {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -5346,7 +5234,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$3('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$4('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -5489,17 +5377,30 @@ class Item {
         });
     }
     static create(props) {
-        if (props.seedUid) {
-            if (this.instanceCache.has(props.seedUid)) {
-                const { instance, refCount } = this.instanceCache.get(props.seedUid);
-                this.instanceCache.set(props.seedUid, {
+        if (props.seedUid || props.seedLocalId) {
+            const seedId = props.seedUid || props.seedLocalId;
+            if (Item.instanceCache.has(seedId)) {
+                const { instance, refCount } = Item.instanceCache.get(seedId);
+                Item.instanceCache.set(seedId, {
                     instance,
                     refCount: refCount + 1,
                 });
                 return instance;
             }
+            if (!Item.instanceCache.has(props.seedLocalId)) {
+                const newInstance = new Item(props);
+                Item.instanceCache.set(seedId, {
+                    instance: newInstance,
+                    refCount: 1,
+                });
+                return newInstance;
+            }
         }
         const newInstance = new Item(props);
+        Item.instanceCache.set(newInstance.seedUid || newInstance.seedLocalId, {
+            instance: newInstance,
+            refCount: 1,
+        });
         return newInstance;
     }
     static find(_b) {
@@ -5644,345 +5545,44 @@ const GET_ALL_PROPERTIES_FOR_ALL_VERSIONS = graphql(/* GraphQL */ `
   }
 `);
 
-const logger$2 = debug('app:react:index');
-const useItemProperty = (propertyName, seedLocalId) => {
-    const [property, setProperty] = useImmer(undefined);
-    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(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);
-    useEffect(() => {
-        if (property && property.value !== value) {
-            readFromDb();
-        }
-    }, [property, value]);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (isReadingFromDb) {
-            return;
-        }
-        setIsReadingFromDb(true);
-        const foundProperty = yield ItemProperty.find({ propertyName, seedLocalId });
-        setIsReadingFromDb(false);
-        if (!foundProperty) {
-            logger$2(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
-            return;
-        }
-        setProperty(() => foundProperty);
-        setIsInitialized(true);
-    }), [isReadingFromDb]);
-    useEffect(() => {
-        readFromDb();
-    }, []);
-    // TODO: How can we force a re-render when the property is updated?
-    // Right now, the value will trigger an update because it's using a selector
-    // and a change is pushed to the hook listener.
-    return {
-        property,
-        isInitialized,
-        isReadingFromDb,
-        value,
-        status,
-    };
-};
-const useItem = ({ modelName, seedLocalId, seedUid }) => {
-    const [item, setItem] = useImmer(undefined);
-    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const { status, internalStatus } = useGlobalServiceStatus();
-    const context = useSelector(item === null || item === void 0 ? void 0 : item.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.context);
-    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        if (internalStatus !== 'ready' ||
-            (!seedUid && !seedLocalId) ||
-            isReadingFromDb) {
-            return;
-        }
-        const foundItem = yield Item.find({
-            modelName,
-            seedLocalId,
-            seedUid,
-        });
-        if (!foundItem) {
-            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
-            return;
-        }
-        setItem(() => foundItem);
-        setIsInitialized(true);
-    }), [internalStatus, isReadingFromDb]);
-    useEffect(() => {
-        if (internalStatus === 'ready') {
-            readFromDb();
-        }
-    }, [internalStatus, status]);
-    useEffect(() => {
-        const seedId = seedUid || seedLocalId;
-        eventEmitter.addListener(`item.${modelName}.${seedId}.update`, readFromDb);
-        return () => {
-            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
-        };
-    }, []);
+const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId }) {
+    const getVersionStatement = `SELECT local_id,
+                                      uid,
+                                      seed_local_id,
+                                      seed_uid,
+                                      seed_type,
+                                      note,
+                                      attestation_created_at,
+                                      attestation_raw,
+                                      created_at,
+                                      updated_at
+                               FROM versions
+                               WHERE local_id = '${seedLocalId}';`;
+    const { rows } = yield runQueryForStatement(getVersionStatement);
+    if (!rows || !rows.length) {
+        return;
+    }
+    const seedValues = rows[0];
     return {
-        item,
-        isInitialized,
-        isReadingFromDb,
-        context,
+        localId: seedValues[0],
+        uid: seedValues[1],
+        seedLocalId: seedValues[2],
+        seedUid: seedValues[3],
+        seedType: seedValues[4],
+        note: seedValues[5],
+        attestationCreatedAt: seedValues[6],
+        attestationRaw: seedValues[7],
+        createdAt: seedValues[8],
+        updatedAt: seedValues[9],
     };
-};
-const useItems = ({ modelName, options }) => {
-    const [items, setItems] = useImmer([]);
-    const [isReadingDb, setIsReadingDb] = useState(false);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const { dbsAreReady } = useDbsAreReady();
-    const modelNameRef = useRef(modelName);
-    const refresh = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        eventEmitter.emit('item.requestAll', { modelName });
-    }), []);
-    const readFromDb = useCallback((event) => __awaiter(void 0, void 0, void 0, function* () {
-        if (!event ||
-            !event.modelName ||
-            event.modelName !== modelNameRef.current ||
-            isReadingDb) {
-            return;
-        }
-        setIsReadingDb(true);
-        const allItems = yield Item.all(modelNameRef.current);
-        setItems(() => allItems);
-        setIsReadingDb(false);
-    }), [modelName]);
-    useEffect(() => {
-        if (dbsAreReady && !isInitialized) {
-            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
-                yield readFromDb({ modelName });
-                setIsInitialized(true);
-            });
-            _fetchItems();
-        }
-    }, [dbsAreReady, isInitialized]);
-    useEffect(() => {
-        eventEmitter.addListener('item.requestAll', readFromDb);
-        return () => {
-            eventEmitter.removeListener('item.requestAll');
-        };
-    }, []);
-    return {
-        items: orderBy(items, [
-            (item) => item.lastVersionPublishedAt ||
-                item.attestationCreatedAt ||
-                item.createdAt,
-        ], ['desc']),
-        isReadingDb,
-        isInitialized,
-        refresh,
-    };
-};
-const useDbsAreReady = () => {
-    const [dbsAreReady, setDbsAreReady] = useState(false);
-    const update = useCallback(() => {
-        if (dbsAreReady) {
-            return;
-        }
-        setDbsAreReady(true);
-    }, []);
-    useEffect(() => {
-        let globalSubscription;
-        let internalSubscription;
-        const _waitForDbs = () => __awaiter(void 0, void 0, void 0, function* () {
-            const globalService = getGlobalService();
-            const internalService = globalService.getSnapshot().context.internalService;
-            if (!internalService) {
-                logger$2('[useDbsAreReady] [useEffect] no internalService');
-                globalSubscription = globalService.subscribe(({ context }) => {
-                    if (!internalSubscription && context && context.internalService) {
-                        globalSubscription === null || globalSubscription === void 0 ? void 0 : globalSubscription.unsubscribe();
-                        internalSubscription = context.internalService.subscribe((snapshot) => {
-                            if (snapshot.value === 'ready') {
-                                update();
-                                internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-                            }
-                        });
-                    }
-                });
-                return;
-            }
-            const currentState = internalService.getSnapshot().value;
-            if (currentState === 'ready') {
-                update();
-                return;
-            }
-            internalSubscription = internalService.subscribe((snapshot) => {
-                if (snapshot.value === 'ready') {
-                    update();
-                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
-                }
-            });
-        });
-        _waitForDbs();
-        return () => {
-            if (globalSubscription) {
-                globalSubscription.unsubscribe();
-            }
-            if (internalSubscription) {
-                internalSubscription.unsubscribe();
-            }
-        };
-    }, []);
-    return {
-        dbsAreReady,
-    };
-};
-const useItemIsReady = () => {
-    const [itemListenersReady, setItemListenersReady] = useState(false);
-    const itemEventListenersHandler = useCallback((_) => {
-        setItemListenersReady(true);
-    }, []);
-    useEffect(() => {
-        const areReady = getAreItemEventHandlersReady();
-        if (areReady) {
-            itemEventListenersHandler(true);
-        }
-        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
-        return () => {
-            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
-        };
-    }, []);
-    return {
-        isReady: itemListenersReady,
-    };
-};
-const useItemProperties = (item) => {
-    const [propertyObj, setPropertyObj] = useImmer({});
-    useState(false);
-    const updatePropertyObj = useCallback((event) => {
-        if (!item) {
-            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
-            return;
-        }
-        const { propertyName, propertyValue } = event;
-        if (!propertyName) {
-            return;
-        }
-        setPropertyObj((draft) => {
-            draft[propertyName] = propertyValue;
-        });
-    }, [item]);
-    useEffect(() => {
-        if (!item) {
-            return;
-        }
-        const eventKey = `item.${item.seedLocalId}.property.update`;
-        eventEmitter.addListener(eventKey, updatePropertyObj);
-        return () => {
-            eventEmitter.removeListener(eventKey, updatePropertyObj);
-        };
-    }, [item]);
-    return {
-        properties: propertyObj,
-    };
-};
-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 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 useGlobalServiceStatus = () => {
-    const globalService = getGlobalService();
-    const status = useSelector(globalService, (snapshot) => {
-        return snapshot.value;
-    });
-    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
-        if (!snapshot) {
-            return;
-        }
-        return snapshot.value;
-    });
-    useSelector(globalService, (snapshot) => {
-        return snapshot.context.internalService;
-    });
-    return {
-        status,
-        internalStatus,
-    };
-};
-
-const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId }) {
-    const getVersionStatement = `SELECT local_id,
-                                      uid,
-                                      seed_local_id,
-                                      seed_uid,
-                                      seed_type,
-                                      note,
-                                      attestation_created_at,
-                                      attestation_raw,
-                                      created_at,
-                                      updated_at
-                               FROM versions
-                               WHERE local_id = '${seedLocalId}';`;
-    const { rows } = yield runQueryForStatement(getVersionStatement);
-    if (!rows || !rows.length) {
-        return;
-    }
-    const seedValues = rows[0];
-    return {
-        localId: seedValues[0],
-        uid: seedValues[1],
-        seedLocalId: seedValues[2],
-        seedUid: seedValues[3],
-        seedType: seedValues[4],
-        note: seedValues[5],
-        attestationCreatedAt: seedValues[6],
-        attestationRaw: seedValues[7],
-        createdAt: seedValues[8],
-        updatedAt: seedValues[9],
-    };
-});
-
-const logger$1 = debug('app:write');
-const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
-    if (!modelName || (!seedLocalId && !seedUid)) {
-        return;
-    }
-    eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
+});
+
+const logger$3 = debug('app:write');
+const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
+    if (!modelName || (!seedLocalId && !seedUid)) {
+        return;
+    }
+    eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
 };
 const createSeed = (_a) => __awaiter(void 0, [_a], void 0, function* ({ type }) {
     const appDb = getAppDb();
@@ -6055,7 +5655,7 @@ const deleteItem = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoca
 });
 const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function* ({ propertyLocalId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, }) {
     if (!propertyLocalId && !seedLocalId) {
-        logger$1(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$3(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -6094,7 +5694,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
         const schemaUid = mostRecentRecord[9];
         const easDataType = mostRecentRecord[10];
         if (propertyValueFromDb === newValue) {
-            logger$1(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$3(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
             return;
         }
         // This means we already have a local-only record so we should just update that one
@@ -6190,25 +5790,473 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
     sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
 });
 
-const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, seedLocalId, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
-    let { newValue } = event;
-    if (existingValue === newValue) {
-        sendBack({ type: 'saveValueToDbSuccess' });
-        return;
-    }
-    const _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        let refResolvedValue;
-        let refResolvedDisplayValue;
-        let refSeedType;
-        let propertyName = propertyNameRaw;
-        let versionLocalId;
-        if (propertyRecordSchema &&
-            propertyRecordSchema.dataType === 'Relation') {
-            refResolvedValue = newValue;
-            if (!propertyName.endsWith('Id')) {
-                propertyName = `${propertyName}Id`;
-            }
+const logger$2 = debug('app:react:index');
+const useItemProperty = (propertyName, seedLocalId) => {
+    const [property, setProperty] = useImmer(undefined);
+    const [isReadingFromDb, setIsReadingFromDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(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);
+    useEffect(() => {
+        if (property && property.value !== value) {
+            readFromDb();
+        }
+    }, [property, value]);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingFromDb) {
+            return;
+        }
+        setIsReadingFromDb(true);
+        const foundProperty = yield ItemProperty.find({ propertyName, seedLocalId });
+        setIsReadingFromDb(false);
+        if (!foundProperty) {
+            logger$2(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            return;
+        }
+        setProperty(() => foundProperty);
+        setIsInitialized(true);
+    }), [isReadingFromDb]);
+    useEffect(() => {
+        readFromDb();
+    }, []);
+    // TODO: How can we force a re-render when the property is updated?
+    // Right now, the value will trigger an update because it's using a selector
+    // and a change is pushed to the hook listener.
+    return {
+        property,
+        isInitialized,
+        isReadingFromDb,
+        value,
+        status,
+    };
+};
+const useItem = ({ modelName, seedLocalId, seedUid }) => {
+    const [item, setItem] = useImmer(undefined);
+    const [itemSubscription, setItemSubscription] = useState();
+    const { status, internalStatus } = useGlobalServiceStatus();
+    const isReadingDb = useRef(false);
+    const itemStatus = useSelector(item === null || item === void 0 ? void 0 : item.getService(), (snapshot) => snapshot === null || snapshot === void 0 ? void 0 : snapshot.value);
+    const updateItem = useCallback((newItem) => {
+        setItem(() => newItem);
+    }, []);
+    const readFromDb = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (isReadingDb.current ||
+            internalStatus !== 'ready' ||
+            (!seedUid && !seedLocalId)) {
+            return;
+        }
+        isReadingDb.current = true;
+        const foundItem = yield Item.find({
+            modelName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!foundItem) {
+            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            return;
+        }
+        updateItem(foundItem);
+        isReadingDb.current = false;
+    }), [internalStatus]);
+    useEffect(() => {
+        if (internalStatus === 'ready') {
+            readFromDb();
+        }
+    }, [internalStatus, status]);
+    useEffect(() => {
+        if (item && !itemSubscription) {
+            const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
+                const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
+                if (!newItem) {
+                    logger$2('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    return;
+                }
+                setItem(() => newItem);
+            }));
+            setItemSubscription(subscription);
+        }
+        return () => {
+            itemSubscription === null || itemSubscription === void 0 ? void 0 : itemSubscription.unsubscribe();
+        };
+    }, [item, itemSubscription]);
+    useEffect(() => {
+        const seedId = seedUid || seedLocalId;
+        eventEmitter.addListener(`item.${modelName}.${seedId}.update`, readFromDb);
+        return () => {
+            eventEmitter.removeListener(`item.${modelName}.${seedId}.update`, readFromDb);
+        };
+    }, []);
+    return {
+        item,
+        itemStatus,
+    };
+};
+const useItems = ({ modelName, options }) => {
+    const [items, setItems] = useImmer([]);
+    const [isReadingDb, setIsReadingDb] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const { dbsAreReady } = useDbsAreReady();
+    const modelNameRef = useRef(modelName);
+    const readFromDb = useCallback((event) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!event ||
+            !event.modelName ||
+            event.modelName !== modelNameRef.current ||
+            isReadingDb) {
+            return;
+        }
+        setIsReadingDb(true);
+        const allItems = yield Item.all(modelNameRef.current);
+        setItems(() => allItems);
+        setIsReadingDb(false);
+    }), [modelName]);
+    useEffect(() => {
+        if (dbsAreReady && !isInitialized) {
+            const _fetchItems = () => __awaiter(void 0, void 0, void 0, function* () {
+                yield readFromDb({ modelName });
+                setIsInitialized(true);
+            });
+            _fetchItems();
+        }
+    }, [dbsAreReady, isInitialized]);
+    useEffect(() => {
+        eventEmitter.addListener('item.requestAll', readFromDb);
+        return () => {
+            eventEmitter.removeListener('item.requestAll');
+        };
+    }, []);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']).slice(0, 10),
+        isReadingDb,
+        isInitialized,
+    };
+};
+const useDbsAreReady = () => {
+    const [dbsAreReady, setDbsAreReady] = useState(false);
+    const update = useCallback(() => {
+        if (dbsAreReady) {
+            return;
+        }
+        setDbsAreReady(true);
+    }, []);
+    useEffect(() => {
+        let globalSubscription;
+        let internalSubscription;
+        const _waitForDbs = () => __awaiter(void 0, void 0, void 0, function* () {
+            const globalService = getGlobalService();
+            const internalService = globalService.getSnapshot().context.internalService;
+            if (!internalService) {
+                logger$2('[useDbsAreReady] [useEffect] no internalService');
+                globalSubscription = globalService.subscribe(({ context }) => {
+                    if (!internalSubscription && context && context.internalService) {
+                        globalSubscription === null || globalSubscription === void 0 ? void 0 : globalSubscription.unsubscribe();
+                        internalSubscription = context.internalService.subscribe((snapshot) => {
+                            if (snapshot.value === 'ready') {
+                                update();
+                                internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+                            }
+                        });
+                    }
+                });
+                return;
+            }
+            const currentState = internalService.getSnapshot().value;
+            if (currentState === 'ready') {
+                update();
+                return;
+            }
+            internalSubscription = internalService.subscribe((snapshot) => {
+                if (snapshot.value === 'ready') {
+                    update();
+                    internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
+                }
+            });
+        });
+        _waitForDbs();
+        return () => {
+            if (globalSubscription) {
+                globalSubscription.unsubscribe();
+            }
+            if (internalSubscription) {
+                internalSubscription.unsubscribe();
+            }
+        };
+    }, []);
+    return {
+        dbsAreReady,
+    };
+};
+const useItemIsReady = () => {
+    const [itemListenersReady, setItemListenersReady] = useState(false);
+    const itemEventListenersHandler = useCallback((_) => {
+        setItemListenersReady(true);
+    }, []);
+    useEffect(() => {
+        const areReady = getAreItemEventHandlersReady();
+        if (areReady) {
+            itemEventListenersHandler(true);
+        }
+        eventEmitter.addListener('item.events.setupAllItemsEventHandlers', itemEventListenersHandler);
+        return () => {
+            eventEmitter.removeListener('item.events.setupAllItemsEventHandlers');
+        };
+    }, []);
+    return {
+        isReady: itemListenersReady,
+    };
+};
+const useItemProperties = (item) => {
+    const [propertyObj, setPropertyObj] = useImmer({});
+    useState(false);
+    const updatePropertyObj = useCallback((event) => {
+        if (!item) {
+            console.error('[XXXXXX] [updatePropertyObj] no item when expected');
+            return;
+        }
+        const { propertyName, propertyValue } = event;
+        if (!propertyName) {
+            return;
+        }
+        setPropertyObj((draft) => {
+            draft[propertyName] = propertyValue;
+        });
+    }, [item]);
+    useEffect(() => {
+        if (!item) {
+            return;
+        }
+        const eventKey = `item.${item.seedLocalId}.property.update`;
+        eventEmitter.addListener(eventKey, updatePropertyObj);
+        return () => {
+            eventEmitter.removeListener(eventKey, updatePropertyObj);
+        };
+    }, [item]);
+    return {
+        properties: propertyObj,
+    };
+};
+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 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 useGlobalServiceStatus = () => {
+    const globalService = getGlobalService();
+    const status = useSelector(globalService, (snapshot) => {
+        return snapshot.value;
+    });
+    const internalStatus = useSelector(globalService.getSnapshot().context.internalService, (snapshot) => {
+        if (!snapshot) {
+            return;
+        }
+        return snapshot.value;
+    });
+    useSelector(globalService, (snapshot) => {
+        return snapshot.context.internalService;
+    });
+    return {
+        status,
+        internalStatus,
+    };
+};
+
+const logger$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 db = getAppDb();
+        let hydrateQuery;
+        let safeValue = propertyValue;
+        let propertyNameQuery = eq(metadata.propertyName, propertyName);
+        if (safeValue && typeof propertyValue === 'string') {
+            safeValue = escapeSqliteString(propertyValue);
+        }
+        if (propertyRecordSchema &&
+            propertyRecordSchema.ref &&
+            propertyRecordSchema.dataType === 'Relation') {
+            let missingPropertyNameVariant;
+            if (propertyName.endsWith('Id')) {
+                missingPropertyNameVariant = propertyName.slice(0, -2);
+            }
+            if (!propertyName.endsWith('Id')) {
+                missingPropertyNameVariant = propertyName + 'Id';
+            }
+            propertyNameQuery = or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, missingPropertyNameVariant));
+        }
+        const selectFromStatement = db
+            .select({
+            localId: metadata.localId,
+            uid: metadata.uid,
+            propertyName: metadata.propertyName,
+            propertyValue: metadata.propertyValue,
+            seedLocalId: metadata.seedLocalId,
+            seedUid: metadata.seedUid,
+            schemaUid: metadata.schemaUid,
+            refResolvedValue: metadata.refResolvedValue,
+            refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+        })
+            .from(metadata);
+        if (seedUid && !seedLocalId) {
+            hydrateQuery = selectFromStatement.where(and(eq(metadata.seedUid, seedUid), propertyNameQuery));
+        }
+        if (seedUid && seedLocalId) {
+            hydrateQuery = selectFromStatement.where(and(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid), propertyNameQuery));
+        }
+        if (!seedUid && seedLocalId) {
+            hydrateQuery = selectFromStatement.where(and(eq(metadata.seedLocalId, seedLocalId), propertyNameQuery));
+        }
+        if (!hydrateQuery) {
+            return;
+        }
+        const rows = yield hydrateQuery.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, refResolvedValue, refResolvedDisplayValue, } = firstRow;
+        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}`);
+        }
+        sendBack({
+            type: 'updateContext',
+            localId,
+            uid,
+            propertyValue: propertyValueFromDb,
+            seedLocalId: seedLocalIdFromDb,
+            seedUid: seedUidFromDb,
+            schemaUid: schemaUidFromDb,
+            resolveValue: refResolvedValue,
+            resolveDisplayValue: refResolvedDisplayValue,
+            renderValue: refResolvedDisplayValue,
+        });
+        if (propertyNameFromDb === 'storageTransactionId') {
+            const { Item } = yield import('./index-CXe0BS3G.js');
+            const item = yield Item.find({
+                seedLocalId,
+                modelName: itemModelName,
+            });
+            if (item) {
+                for (const [propertyName, property] of Object.entries(item.properties)) {
+                    if (propertyName === 'html' &&
+                        propertyValueFromDb &&
+                        propertyValueFromDb.length === 43) {
+                        const htmlFilePath = `/files/html/${propertyValueFromDb}.html`;
+                        const exists = yield fs.promises.exists(htmlFilePath);
+                        if (!exists) {
+                            return;
+                        }
+                        const renderValue = yield fs.promises
+                            .readFile(htmlFilePath, 'utf8')
+                            .catch((error) => {
+                            logger$1('Error reading html file', error);
+                        });
+                        property
+                            .getService()
+                            .send({ type: 'updateRenderValue', renderValue });
+                        return;
+                    }
+                }
+            }
+        }
+    });
+    _hydrateFromDb().then(() => {
+        sendBack({ type: 'hydrateFromDbSuccess' });
+    });
+});
+
+const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, seedLocalId, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
+    let { newValue } = event;
+    if (existingValue === newValue) {
+        sendBack({ type: 'saveValueToDbSuccess' });
+        return;
+    }
+    const _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        let refResolvedValue;
+        let refResolvedDisplayValue;
+        let refSeedType;
+        let propertyName = propertyNameRaw;
+        let versionLocalId;
+        if (propertyRecordSchema &&
+            propertyRecordSchema.dataType === 'Relation') {
+            refResolvedValue = newValue;
+            if (!propertyName.endsWith('Id')) {
+                propertyName = `${propertyName}Id`;
+            }
             let fileType;
             const dirs = yield fs.promises.readdir('/files');
             for (const dir of dirs) {
@@ -6245,7 +6293,6 @@ const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) =>
         });
         sendBack({
             type: 'updateContext',
-            isSaving: false,
             propertyValue: newValue,
             renderValue: refResolvedDisplayValue,
         });
@@ -6309,11 +6356,7 @@ const propertyMachine = setup({
         },
     },
     states: {
-        idle: {
-            on: {
-                refresh: 'hydratingFromDb',
-            },
-        },
+        idle: {},
         waitingForDb: {
             on: {
                 waitForDbSuccess: {
@@ -6325,6 +6368,7 @@ const propertyMachine = setup({
             },
             invoke: {
                 src: 'waitForDb',
+                input: ({ context }) => ({ context }),
             },
         },
         hydratingFromDb: {
@@ -6382,13 +6426,13 @@ const propertyMachine = setup({
         },
         saving: {
             on: {
-                saveSuccess: {
+                saveValueToDbSuccess: {
                     target: 'idle',
                     actions: assign({
                         isSaving: false,
                     }),
                 },
-                saveFailure: {
+                saveValueToDbFailure: {
                     target: 'idle',
                     actions: assign({
                         isSaving: false,
@@ -6821,7 +6865,7 @@ const client = {
             console.error('fs listeners not ready during init');
         }
         globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-CxqrGPwe.js').then(({ models }) => {
+        import('./seed.schema.config-Dg9Q0kx4.js').then(({ models }) => {
             for (const [key, value] of Object.entries(models)) {
                 modelStore.set(key, value);
             }
@@ -6879,4 +6923,4 @@ const client = {
 };
 
 export { APP_DB_CONFIG as A, useCreateItem as B, CHILD_SNAPSHOT as C, DB_NAME_SDK_CONFIG as D, useItemProperty as E, useDeleteItem as F, GET_SCHEMAS as G, getGlobalService as H, Item as I, Json as J, getCorrectId as K, List as L, Model as M, Property as P, Relation as R, SCHEMA_NJK as S, Text as T, __decorate as _, GET_SEEDS as a, GET_SEED_IDS as b, GET_STORAGE_TRANSACTION_ID as c, GET_VERSIONS as d, GET_PROPERTIES as e, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as f, itemMachineAll as g, __metadata as h, itemMachineSingle as i, internalMachine as j, isNode as k, isBrowser as l, isReactNative as m, __awaiter as n, models as o, SCHEMA_TS as p, SDK_DB_CONFIG as q, SEED_DB_CONFIG as r, addModelsToInternalDb as s, client as t, ImageSrc as u, ItemProperty as v, withSeed as w, useItems as x, useItem as y, useItemProperties as z };
-//# sourceMappingURL=index-Dg73YrcZ.js.map
+//# sourceMappingURL=index-Dd2ggBQg.js.map