@seedprotocol/sdk 0.2.44 → 0.2.46

package/dist/{index-DanGFTTF.js → index-CGeSKilQ.js}

@@ -2,21 +2,22 @@ import { immerable, produce, enableMapSet } from 'immer';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
 import { fromCallback, setup, assign, waitFor, createActor, raise } from 'xstate';
-import { b as BaseQueryClient, a as BaseEasClient, G as GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY, f as GLOBAL_INITIALIZING_SEND_CONFIG, g as GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES, h as GLOBAL_ADDING_MODELS_TO_DB_SUCCESS, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, d as BROWSER_FS_TOP_DIR, j as DB_CREATING_SUCCESS, k as DB_VALIDATING_SUCCESS, l as DB_VALIDATING_WAIT, m as DB_MIGRATING_SUCCESS, M as MachineIds, n as DB_WAITING_FOR_FILES_RECEIVED, o as DB_MIGRATING_WAIT, p as DbState, I as INTERNAL_VALIDATING_INPUT_SUCCESS, q as ARWEAVE_HOST, B as BaseArweaveClient, c as BaseFileManager, r as INTERNAL_CONFIGURING_FS_SUCCESS, s as INTERNAL_SAVING_CONFIG_SUCCESS, t as INTERNAL_LOADING_APP_DB_SUCCESS, u as DB_ON_SNAPSHOT, v as DB_NAME_APP, w as InternalState, P as PublishMachineStates, x as GlobalState, y as INTERNAL_DATA_TYPES, z as ImageSize, C as internalPropertyNames, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, F as defaultAttestationData } from './constants-BIdH8wc3.js';
+import { b as BaseQueryClient, a as BaseEasClient, G as GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY, f as GLOBAL_INITIALIZING_SEND_CONFIG, g as GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES, h as GLOBAL_ADDING_MODELS_TO_DB_SUCCESS, D as DB_CHECK_STATUS_UPDATE_PATHS, i as DB_CHECK_STATUS_EXISTS, d as BROWSER_FS_TOP_DIR, j as DB_CREATING_SUCCESS, k as DB_VALIDATING_SUCCESS, l as DB_VALIDATING_WAIT, m as DB_MIGRATING_SUCCESS, n as DB_WAITING_FOR_FILES_RECEIVED, M as MachineIds, o as DB_MIGRATING_WAIT, p as DbState, I as INTERNAL_VALIDATING_INPUT_SUCCESS, q as ARWEAVE_HOST, B as BaseArweaveClient, c as BaseFileManager, r as INTERNAL_CONFIGURING_FS_SUCCESS, s as INTERNAL_SAVING_CONFIG_SUCCESS, t as INTERNAL_LOADING_APP_DB_SUCCESS, u as DB_ON_SNAPSHOT, v as DB_NAME_APP, w as InternalState, P as PublishMachineStates, x as GlobalState, y as INTERNAL_DATA_TYPES, z as ImageSize, C as internalPropertyNames, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, F as defaultAttestationData } from './constants-Dgv-tSO3.js';
+import debug from 'debug';
 import pluralize from 'pluralize';
 import { sqliteTable, text, int, unique } from 'drizzle-orm/sqlite-core';
-import { relations, or, and, isNotNull, not, eq, inArray, sql, like, isNull, getTableColumns, count, max, gt } from 'drizzle-orm';
+import { relations, or, and, isNotNull, not, eq, inArray, sql, like, getTableColumns, isNull, count, max, gt } from 'drizzle-orm';
 import EventEmitter from 'eventemitter3';
 import { customAlphabet } from 'nanoid';
 import * as nanoIdDictionary from 'nanoid-dictionary';
-import fs$1, { fs } from '@zenfs/core';
-import debug from 'debug';
+import fs from '@zenfs/core';
 import { throttle, camelCase, startCase, orderBy } from 'lodash-es';
 import { createBrowserInspector } from '@statelyai/inspect';
 import * as fsNode from 'node:fs';
 import path from 'path';
 import Arweave from 'arweave';
 import { BehaviorSubject } from 'rxjs';
+import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
 import { ZERO_BYTES32, SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { useImmer } from 'use-immer';
@@ -123,6 +124,7 @@ class BaseDb {
     }
 }
 
+debug('app:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -288,7 +290,7 @@ const initialize$3 = fromCallback(({ sendBack, input: { context } }) => {
 
 const eventEmitter = new EventEmitter();
 
-const logger$o = debug('app:shared:helpers');
+const logger$q = debug('app:shared:helpers');
 const { alphanumeric } = nanoIdDictionary;
 const generateId = () => {
     return customAlphabet(alphanumeric, 10)();
@@ -345,7 +347,7 @@ const convertTxIdToImageSrc = async (txId) => {
     const imageFilePath = `/files/images/${txId}`;
     const fileExists = await fs.promises.exists(imageFilePath);
     if (!fileExists) {
-        logger$o(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
+        logger$q(`[ItemView] [updateImageSrc] ${imageFilePath} does not exist`);
         return;
     }
     const uint = await fs.promises.readFile(imageFilePath);
@@ -470,6 +472,7 @@ const AttestationFieldsFragmentDoc = { "kind": "Document", "definitions": [{ "ki
 const SchemaFieldsFragmentDoc = { "kind": "Document", "definitions": [{ "kind": "FragmentDefinition", "name": { "kind": "Name", "value": "schemaFields" }, "typeCondition": { "kind": "NamedType", "name": { "kind": "Name", "value": "Schema" } }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "resolver" } }, { "kind": "Field", "name": { "kind": "Name", "value": "revocable" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schema" } }, { "kind": "Field", "name": { "kind": "Name", "value": "index" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schemaNames" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "name" } }] } }, { "kind": "Field", "name": { "kind": "Name", "value": "time" } }, { "kind": "Field", "name": { "kind": "Name", "value": "txid" } }, { "kind": "Field", "name": { "kind": "Name", "value": "creator" } }] } }] };
 const GetTransactionTagsDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetTransactionTags" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "transactionId" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "ID" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "tags" }, "name": { "kind": "Name", "value": "transaction" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "id" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "transactionId" } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "tags" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "name" } }, { "kind": "Field", "name": { "kind": "Name", "value": "value" } }] } }] } }] } }] };
 const GetSchemasDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetSchemas" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "SchemaWhereInput" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "schemas" }, "name": { "kind": "Name", "value": "schemata" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "where" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schema" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schemaNames" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "name" } }] } }] } }] } }] };
+const GetSchemaByNameDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetSchemaByName" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "SchemaWhereInput" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "schemas" }, "name": { "kind": "Name", "value": "schemata" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "where" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schema" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schemaNames" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "name" } }] } }] } }] } }] };
 const GetSeedsDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetSeeds" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "AttestationWhereInput" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "itemSeeds" }, "name": { "kind": "Name", "value": "attestations" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "where" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } } }, { "kind": "Argument", "name": { "kind": "Name", "value": "orderBy" }, "value": { "kind": "ListValue", "values": [{ "kind": "ObjectValue", "fields": [{ "kind": "ObjectField", "name": { "kind": "Name", "value": "timeCreated" }, "value": { "kind": "EnumValue", "value": "desc" } }] }] } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "decodedDataJson" } }, { "kind": "Field", "name": { "kind": "Name", "value": "attester" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schema" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "schemaNames" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "name" } }] } }] } }, { "kind": "Field", "name": { "kind": "Name", "value": "refUID" } }, { "kind": "Field", "name": { "kind": "Name", "value": "revoked" } }, { "kind": "Field", "name": { "kind": "Name", "value": "schemaId" } }, { "kind": "Field", "name": { "kind": "Name", "value": "timeCreated" } }, { "kind": "Field", "name": { "kind": "Name", "value": "isOffchain" } }] } }] } }] };
 const GetSeedIdsDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetSeedIds" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "AttestationWhereInput" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "itemSeedIds" }, "name": { "kind": "Name", "value": "attestations" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "where" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } } }, { "kind": "Argument", "name": { "kind": "Name", "value": "orderBy" }, "value": { "kind": "ListValue", "values": [{ "kind": "ObjectValue", "fields": [{ "kind": "ObjectField", "name": { "kind": "Name", "value": "timeCreated" }, "value": { "kind": "EnumValue", "value": "desc" } }] }] } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }] } }] } }] };
 const GetStorageTransactionIdDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "GetStorageTransactionId" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "AttestationWhereInput" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "alias": { "kind": "Name", "value": "storageTransactionId" }, "name": { "kind": "Name", "value": "attestations" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "where" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "where" } } }, { "kind": "Argument", "name": { "kind": "Name", "value": "orderBy" }, "value": { "kind": "ListValue", "values": [{ "kind": "ObjectValue", "fields": [{ "kind": "ObjectField", "name": { "kind": "Name", "value": "timeCreated" }, "value": { "kind": "EnumValue", "value": "desc" } }] }] } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "id" } }, { "kind": "Field", "name": { "kind": "Name", "value": "decodedDataJson" } }] } }] } }] };
@@ -495,10 +498,11 @@ const GetSchemaUidsDocument = { "kind": "Document", "definitions": [{ "kind": "O
  * Learn more about it here: https://the-guild.dev/graphql/codegen/plugins/presets/preset-client#reducing-bundle-size
  */
 const documents = {
-    "\n  query GetTransactionTags($transactionId: ID!) {\n    tags: transaction(id: $transactionId) {\n      id\n      tags {\n        name\n        value\n      }\n    }\n  }\n": GetTransactionTagsDocument,
     "\n  fragment attestationFields on Attestation {\n    id\n    decodedDataJson\n    attester\n    schema {\n      schemaNames {\n        name\n      }\n    }\n    refUID\n    revoked\n    schemaId\n    txid\n    timeCreated\n    time\n    isOffchain\n  }\n": AttestationFieldsFragmentDoc,
     "\n  fragment schemaFields on Schema {\n    id\n    resolver\n    revocable\n    schema\n    index\n    schemaNames {\n      name\n    }\n    time\n    txid\n    creator\n  }\n": SchemaFieldsFragmentDoc,
+    "\n  query GetTransactionTags($transactionId: ID!) {\n    tags: transaction(id: $transactionId) {\n      id\n      tags {\n        name\n        value\n      }\n    }\n  }\n": GetTransactionTagsDocument,
     "\n  query GetSchemas($where: SchemaWhereInput!) {\n    schemas: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n": GetSchemasDocument,
+    "\n  query GetSchemaByName($where: SchemaWhereInput!) {\n    schemas: schemata(where: $where) {\n      id\n      schema\n      schemaNames {\n        name\n      }\n    }\n  }\n": GetSchemaByNameDocument,
     "\n  query GetSeeds($where: AttestationWhereInput!) {\n    itemSeeds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n      decodedDataJson\n      attester\n      schema {\n        schemaNames {\n          name\n        }\n      }\n      refUID\n      revoked\n      schemaId\n      timeCreated\n      isOffchain\n    }\n  }\n": GetSeedsDocument,
     "\n  query GetSeedIds($where: AttestationWhereInput!) {\n    itemSeedIds: attestations(where: $where, orderBy: [{ timeCreated: desc }]) {\n      id\n    }\n  }\n": GetSeedIdsDocument,
     "\n  query GetStorageTransactionId($where: AttestationWhereInput!) {\n    storageTransactionId: attestations(\n      where: $where\n      orderBy: [{ timeCreated: desc }]\n    ) {\n      id\n      decodedDataJson\n    }\n  }\n": GetStorageTransactionIdDocument,
@@ -528,7 +532,7 @@ const GET_SCHEMAS = graphql(/* GraphQL */ `
 `);
 const GET_SCHEMA_BY_NAME = graphql(/* GraphQL */ `
   query GetSchemaByName($where: SchemaWhereInput!) {
-    schema: schemata(where: $where) {
+    schemas: schemata(where: $where) {
       id
       schema
       schemaNames {
@@ -1225,7 +1229,7 @@ const getEnvironment = () => {
     return 'node';
 };
 
-const logger$n = debug('app:services:global:actors:initialize');
+const logger$p = debug('app:services:global:actors:initialize');
 const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints, arweaveDomain, addresses, } = context;
     if (!internalService) {
@@ -1244,7 +1248,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     const _initInternal = async () => {
         return new Promise((resolve) => {
             internalSubscription = internalService.subscribe((snapshot) => {
-                logger$n('[sdk] [internal] snapshot', snapshot);
+                logger$p('[sdk] [internal] snapshot', snapshot);
                 if (snapshot.value === 'ready') {
                     resolve();
                 }
@@ -1289,7 +1293,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
         await fetchSchemaUids();
     };
     _initFileSystem().then(() => {
-        logger$n('[global/actors] File system initialized');
+        logger$p('[global/actors] File system initialized');
     });
     _initInternal()
         .then(() => {
@@ -1299,7 +1303,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
         return _initEas();
     })
         .then(() => {
-        logger$n('[global/actors] Internal initialized');
+        logger$p('[global/actors] Internal initialized');
         sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
         internalSubscription?.unsubscribe();
     });
@@ -1312,7 +1316,7 @@ const initialize$2 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$m = debug('app:services:global:actors:getSchemaForModel');
+const logger$o = debug('app:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -1328,12 +1332,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$m('[service/actor] [getSchemaForModel] model:', model);
+    logger$o('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$l = debug('app:services:global:actors:addModelsToDb');
+const logger$n = debug('app:services:global:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models: models$1 } = context;
     const _addModelsToDb = async () => {
@@ -1341,7 +1345,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = await import('./seed.schema.config-DdCq87m_.js');
+        const { models: SeedModels } = await import('./seed.schema.config-BXWvwsZQ.js');
         const allModels = {
             ...SeedModels,
             ...models$1,
@@ -1349,7 +1353,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
         for (const [modelName, _] of Object.entries(allModels)) {
-            logger$l('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$n('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = await appDb
                 .select()
@@ -1359,7 +1363,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 await appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$l('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$n('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = await appDb
                     .select({
                     id: models.id,
@@ -1429,10 +1433,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$k = debug('app:services:db:actors:checkStatus');
+const logger$m = debug('app:services:db:actors:checkStatus');
 const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     const { dbName } = context;
-    logger$k('[db/actors] checkStatus context', context);
+    logger$m('[db/actors] checkStatus context', context);
     const pathToDir = `${BROWSER_FS_TOP_DIR}`;
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
@@ -1463,9 +1467,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$j = debug('app:services:db:actors:connectToDb');
+const logger$l = debug('app:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$j('[db/actors] connectToDb context', context);
+    logger$l('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     if (!pathToDir || !dbName) {
         throw new Error('pathToDir and dbName are required');
@@ -1509,12 +1513,16 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
         }
         return exists;
     };
-    _validate().then(() => {
-        sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir });
-        return;
+    _validate().then((allFilesExist) => {
+        if (allFilesExist) {
+            sendBack({ type: DB_VALIDATING_SUCCESS, pathToDb, pathToDir });
+            return;
+        }
+        sendBack({ type: DB_VALIDATING_WAIT });
     });
 });
 
+const logger$k = debug('app:helpers:files');
 /**
  * Waits for a file to exist at the specified path.
  * @param {string} filePath - The path of the file to check.
@@ -1522,10 +1530,16 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
  * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
  * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
  */
-const waitForFile = (filePath, interval = 500, timeout = 10000) => {
+const waitForFile = (filePath, interval = 1000, timeout = 60000) => {
     return new Promise((resolve, reject) => {
         const startTime = Date.now();
-        const _interval = setInterval(() => {
+        let isBusy = false;
+        const _interval = setInterval(async () => {
+            logger$k('waitForFile', filePath);
+            if (isBusy) {
+                return;
+            }
+            isBusy = true;
             if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
                 clearInterval(_interval);
                 resolve(true);
@@ -1534,6 +1548,7 @@ const waitForFile = (filePath, interval = 500, timeout = 10000) => {
                 clearInterval(_interval);
                 reject(new Error('Timeout exceeded while waiting for file'));
             }
+            isBusy = false;
         }, interval);
         // retry(
         //   {
@@ -1559,38 +1574,16 @@ const waitForFile = (filePath, interval = 500, timeout = 10000) => {
     });
 };
 
-const logger$i = debug('app:services:db:actors:migrate');
+const logger$j = debug('app:services:db:actors:migrate');
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dbId, dbName } = context;
-    logger$i('[db/actors] migrate context', context);
+    logger$j('[db/actors] migrate context', context);
     let journalExists = false;
-    // const _initFs = async (): Promise<void> => {
-    //   const handle = await navigator.storage.getDirectory()
-    //   // await configure({ backend: WebAccess, handle })
-    //   await configureSingle({
-    //     backend: WebAccess,
-    //     handle,
-    //   })
-    // }
-    //
-    // _initFs()
     const _checkForFiles = async () => {
         const journalPath = `/${pathToDbDir}/meta/_journal.json`;
-        journalExists = await fs$1.promises.exists(journalPath);
+        journalExists = await fs.promises.exists(journalPath);
         if (!journalExists) {
-            await waitForFile(journalPath);
-            // const handle = await navigator.storage.getDirectory()
-            //
-            // await configureSingle({
-            //   backend: WebAccess,
-            //   handle,
-            // })
-            // window.location.reload()
-            // setTimeout(() => {
-            //   _checkForFiles().then(() => {
-            //     return
-            //   })
-            // }, 500)
+            await waitForFile(journalPath, 500, 60000);
         }
     };
     const _migrate = async () => {
@@ -1608,7 +1601,27 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$h = debug('app:services:db:machine');
+debug('app:services:db:actors:waitForFiles');
+const waitForFiles$1 = fromCallback(({ sendBack, input: { context } }) => {
+    const { pathToDbDir } = context;
+    const _waitForFiles = async () => {
+        return new Promise((resolve) => {
+            const interval = setInterval(async () => {
+                const journalExists = await fs.promises.exists(`${pathToDbDir}/meta/_journal.json`);
+                if (journalExists) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    };
+    _waitForFiles().then(() => {
+        sendBack({ type: DB_WAITING_FOR_FILES_RECEIVED });
+        return;
+    });
+});
+
+const logger$i = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -1620,6 +1633,7 @@ const dbMachine = setup({
         validate,
         connectToDb,
         migrate,
+        waitForFiles: waitForFiles$1,
     },
 }).createMachine({
     id: MachineIds.DB,
@@ -1629,7 +1643,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$h('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$i('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -1638,8 +1652,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$h('[db/machine] updateHasFiles event:', event);
-                    logger$h('[db/machine] updateHasFiles context:', context);
+                    logger$i('[db/machine] updateHasFiles event:', event);
+                    logger$i('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -1728,6 +1742,10 @@ const dbMachine = setup({
                 },
                 [DB_MIGRATING_SUCCESS]: 'ready',
             },
+            invoke: {
+                src: 'waitForFiles',
+                input: ({ context }) => ({ context }),
+            },
         },
         [MIGRATING]: {
             on: {
@@ -1802,7 +1820,7 @@ const prepareDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$g = debug('app:services:internal:helpers');
+const logger$h = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -1813,11 +1831,22 @@ const createDirectories = async (dirPath) => {
         return;
     }
     const parentDir = path.dirname(dirPath);
-    const parentDirExists = await fs.promises.exists(parentDir);
+    let parentDirExists = await fs.promises.exists(parentDir);
     if (!parentDirExists) {
         await createDirectories(parentDir);
     }
-    await fs.promises.mkdir(dirPath, { recursive: true });
+    parentDirExists = await fs.promises.exists(parentDir);
+    if (parentDirExists) {
+        try {
+            await fs.promises.mkdir(dirPath);
+        }
+        catch (error) {
+            logger$h(`[Error] Failed to create directories for ${dirPath}:`, error);
+        }
+    }
+    if (!parentDirExists) {
+        console.log(fs);
+    }
 };
 let busy = false;
 const downloadFile = async (url, localFilePath) => {
@@ -1861,10 +1890,17 @@ const downloadFile = async (url, localFilePath) => {
                 }
             }
         }
-        await fs.promises.writeFile(localFilePath, fileData);
+        try {
+            await fs.promises.writeFile(localFilePath, fileData);
+            logger$h(`[downloadFile] Wrote file async to ${localFilePath}`);
+        }
+        catch (error) {
+            fs.writeFileSync(localFilePath, fileData);
+            logger$h(`[downloadFile] Wrote file sync to ${localFilePath}`);
+        }
     }
     catch (error) {
-        logger$g(`[Error] Failed to download file from ${url}:`, error);
+        logger$h(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 };
@@ -1904,7 +1940,7 @@ const syncDbFiles = async ({ filePaths, files }) => {
     fileList = fileList.filter((file) => !filesToExclude.includes(file));
     await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
     await confirmFilesExist(fileList);
-    logger$g('[syncDbFiles] Files synced!');
+    logger$h('[syncDbFiles] Files synced!');
 };
 
 const GET_FILES_METADATA = graphql(/* GraphQL */ `
@@ -2013,10 +2049,10 @@ const saveAppState = async (key, value) => {
 
 const initArweaveClient = async () => {
     if (isBrowser()) {
-        (await import('./ArweaveClient-CA1Vsnow.js')).ArweaveClient;
+        (await import('./ArweaveClient-DQrXvrNN.js')).ArweaveClient;
     }
     if (!isBrowser()) {
-        (await import('./ArweaveClient-MgJXScYG.js')).ArweaveClient;
+        (await import('./ArweaveClient-CoFomTCN.js')).ArweaveClient;
     }
 };
 let domain = 'arweave.net';
@@ -2059,7 +2095,7 @@ const setArweaveDomain = (newDomain) => {
     domain = newDomain;
 };
 
-const logger$f = debug('app:files:download');
+const logger$g = debug('app:files:download');
 const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
     await syncDbFiles(endpoints);
     eventEmitter.emit('fs.downloadAll.success', { eventId });
@@ -2074,7 +2110,9 @@ const downloadAllFilesBinaryRequestHandler = async () => {
         const globalService = getGlobalService();
         const internalService = globalService.getSnapshot().context.internalService;
         if (internalService) {
-            await waitFor(internalService, (snapshot) => snapshot.value === 'ready');
+            await waitFor(internalService, (snapshot) => {
+                return snapshot.value === 'ready';
+            });
             addresses = await getAddressesFromDb();
         }
     }
@@ -2149,7 +2187,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
         try {
             const res = await fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
             if (res.status !== 200) {
-                logger$f(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$g(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 await saveAppState('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -2178,7 +2216,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
             transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
-            logger$f(error);
+            logger$g(error);
         }
     }
     console.log('[download] Calling downloadAllFiles with transactionIdsToDownload', transactionIdsToDownload);
@@ -2229,14 +2267,14 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$e = debug('app:internal:actors:configureFs');
+const logger$f = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService, filesDir, } = context;
-    logger$e('[internal/actors] [configureFs] Configuring FS');
+    logger$f('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = async () => {
-        logger$e('[internal/actors] [configureFs] calling _configureFs');
-        logger$e('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$e('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$f('[internal/actors] [configureFs] calling _configureFs');
+        logger$f('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$f('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         await waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -2247,10 +2285,17 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
             },
         });
         const journalPath = `${filesDir || BROWSER_FS_TOP_DIR}/db/meta/_journal.json`;
-        const journalExists = await fs.promises.exists(journalPath);
+        let journalExists = await fs.promises.exists(journalPath);
+        if (!journalExists) {
+            journalExists = fs.existsSync(journalPath);
+        }
         if (journalExists) {
             appDbService.send({ type: DB_WAITING_FOR_FILES_RECEIVED });
+            logger$f('[internal/actors] [configureFs] fs configured!');
+            return true;
         }
+        sendBack({ type: 'shouldWaitForFiles' });
+        return false;
         // return new Promise<void>((resolve) => {
         //   const interval = setInterval(() => {
         //     journalExistsSync = fs.existsSync(journalPath)
@@ -2265,20 +2310,21 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
         //     }
         //   }, 200)
         // })
-        logger$e('[internal/actors] [configureFs] fs configured!');
     };
     // Some of our dependencies use fs sync functions, which don't work with
     // OPFS. ZenFS creates an async cache of all files so that the sync functions
     // work, but we have to wait for it to be built. Otherwise things like
     // drizzleMigrate will fail since they can't see the migration files yet.
-    _configureFs().then(() => {
-        sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS });
+    _configureFs().then((fsConfigured) => {
+        if (fsConfigured) {
+            sendBack({ type: INTERNAL_CONFIGURING_FS_SUCCESS });
+        }
         return;
     });
     return () => { };
 });
 
-const logger$d = debug('app:services:internal:actors:saveConfig');
+const logger$e = debug('app:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     if (typeof window === 'undefined') {
         console.error('seedInitBrowser called from non-browser context');
@@ -2339,20 +2385,20 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                     value: arweaveDomain || 'arweave.net',
                 },
             });
-            logger$d('[sdk] [internal/actors] Should be done saving');
+            logger$e('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     };
     _saveConfig().then(() => {
-        logger$d('[sdk] [internal/actors] Successfully saved config');
+        logger$e('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$c = debug('app:services:internal:actors:loadAppDb');
+const logger$d = debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -2373,7 +2419,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$c('[sdk] [internal/actors] Successfully loaded app DB');
+        logger$d('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -2382,7 +2428,28 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$b = debug('app:services:internal:machine');
+debug('app:services:internal:actors:waitForFiles');
+const waitForFiles = fromCallback(({ sendBack, input: { context } }) => {
+    const { endpoints } = context;
+    const filesDir = endpoints.files;
+    const _waitForFiles = async () => {
+        return new Promise((resolve) => {
+            const interval = setInterval(async () => {
+                const journalExists = await fs.promises.exists(`${filesDir}/db/meta/_journal.json`);
+                if (journalExists) {
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 1000);
+        });
+    };
+    _waitForFiles().then(() => {
+        sendBack({ type: 'filesReceived' });
+        return;
+    });
+});
+
+const logger$c = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
@@ -2396,6 +2463,7 @@ const internalMachine = setup({
     actors: {
         prepareDb,
         validateInput,
+        waitForFiles,
         configureFs,
         loadAppDb,
         saveConfig,
@@ -2465,12 +2533,26 @@ const internalMachine = setup({
                 input: ({ context, event }) => ({ context, event }),
             },
         },
+        waitingForFiles: {
+            on: {
+                filesReceived: {
+                    target: LOADING_APP_DB,
+                },
+            },
+            invoke: {
+                src: 'waitForFiles',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
         [CONFIGURING_FS]: {
             on: {
                 [INTERNAL_CONFIGURING_FS_SUCCESS]: {
                     target: LOADING_APP_DB,
                     actions: assign({ hasFiles: true }),
                 },
+                shouldWaitForFiles: {
+                    target: 'waitingForFiles',
+                },
             },
             invoke: {
                 src: 'configureFs',
@@ -2487,7 +2569,7 @@ const internalMachine = setup({
                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                     target: SAVING_CONFIG,
                     actions: () => {
-                        logger$b('[sdk] [internal/index] App DB loaded!');
+                        logger$c('[sdk] [internal/index] App DB loaded!');
                     },
                 },
             },
@@ -2513,7 +2595,7 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$b('[sdk] [internal/index] Ready!');
+                logger$c('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -2528,7 +2610,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$b('[sdk] [internal/index] Error!');
+                logger$c('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -2705,7 +2787,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$a = debug('app:allItemsActors:fetchSeeds');
+const logger$b = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -2717,7 +2799,7 @@ const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
         const queryClient = BaseQueryClient.getQueryClient();
         const easClient = BaseEasClient.getEasClient();
         const cachedResults = queryClient.getQueryData(queryKey);
-        logger$a(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$b(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
         const results = await queryClient.fetchQuery({
             queryKey,
             queryFn: async () => easClient.request(GET_SEEDS, queryVariables),
@@ -3166,13 +3248,13 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$9 = debug('app:services:publish:actors:upload');
+const logger$a = debug('app:services:publish:actors:upload');
 const upload = fromCallback(({ sendBack, input: { context } }) => {
     const { localId } = context;
     const _upload = async () => {
         const item = await BaseItem.find({ seedLocalId: localId });
         if (!item) {
-            logger$9('no item with localId', localId);
+            logger$a('no item with localId', localId);
             return false;
         }
         const editedProperties = await item.getEditedProperties();
@@ -4009,6 +4091,30 @@ const itemMachineSingle = setup({
     },
 });
 
+const getMetadataLatest = ({ seedLocalId, seedUid }) => {
+    const appDb = BaseDb.getAppDb();
+    const whereClauses = [];
+    if (seedLocalId) {
+        whereClauses.push(eq(metadata.seedLocalId, seedLocalId));
+    }
+    if (seedUid) {
+        whereClauses.push(eq(metadata.seedUid, seedUid));
+    }
+    const metadataColumns = getTableColumns(metadata);
+    return appDb.$with('metadataLatest').as(appDb
+        .select({
+        ...metadataColumns,
+        rowNum: sql.raw(`
+           ROW_NUMBER() OVER (
+               PARTITION BY property_name 
+               ORDER BY COALESCE(created_at, attestation_created_at) DESC
+           )
+          `).as('rowNum')
+    })
+        .from(metadata)
+        .where(and(...whereClauses)));
+};
+
 const getItemProperties = async ({ seedLocalId, seedUid, edited, }) => {
     const appDb = BaseDb.getAppDb();
     const whereClauses = [isNotNull(metadata.propertyName)];
@@ -4018,15 +4124,7 @@ const getItemProperties = async ({ seedLocalId, seedUid, edited, }) => {
     if (seedLocalId) {
         whereClauses.push(eq(seeds.localId, seedLocalId));
     }
-    // const uidWhereClause: SQL = seedUid
-    //   ? eq(seeds.uid, seedUid)
-    //   : isNull(seeds.uid)
-    // const localWhereClause: SQL = seedLocalId
-    //   ? eq(seeds.localId, seedLocalId)
-    //   : isNull(seeds.localId)
-    // whereClauses.push(or(localWhereClause, uidWhereClause) as SQL)
     whereClauses.push(isNotNull(metadata.propertyName));
-    // whereClauses.push(isNotNull(metadata.easDataType))
     if (typeof edited !== 'undefined') {
         if (edited) {
             whereClauses.push(isNull(metadata.uid));
@@ -4035,16 +4133,13 @@ const getItemProperties = async ({ seedLocalId, seedUid, edited, }) => {
             whereClauses.push(isNotNull(metadata.uid));
         }
     }
-    const metadataColumns = getTableColumns(metadata);
+    // const metadataColumns = getTableColumns(metadata)
+    const metadataLatest = getMetadataLatest({ seedLocalId, seedUid });
     const propertiesData = await appDb
-        .select({
-        ...metadataColumns,
-    })
-        .from(seeds)
-        .leftJoin(metadata, eq(metadata.seedLocalId, seeds.localId))
-        .leftJoin(versions, eq(versions.localId, seeds.localId))
-        .where(and(...whereClauses))
-        .groupBy(metadata.propertyName);
+        .with(metadataLatest)
+        .select()
+        .from(metadataLatest)
+        .where(eq(metadataLatest.rowNum, 1));
     return propertiesData.map(data => ({
         ...data,
         localId: data.localId || '',
@@ -4090,7 +4185,7 @@ const getSeedData = async ({ seedLocalId, seedUid }) => {
     return rows[0];
 };
 
-const logger$8 = debug('app:db:read:getItemData');
+const logger$9 = debug('app:db:read:getItemData');
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -4098,7 +4193,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$8('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$9('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -4133,7 +4228,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
         .groupBy(seeds.localId);
     if (!itemDataRows || itemDataRows.length === 0) {
-        logger$8('[db/queries] [getItemDataFromDb] no itemDataRows');
+        logger$9('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -4252,6 +4347,7 @@ const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
+debug('app:ItemProperty:service:actors:waitForDb');
 const waitForDb = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -4361,7 +4457,7 @@ const getRelationValueData = async (propertyValue) => {
     return rows[0];
 };
 
-const logger$7 = debug('app:property:actors:resolveRelatedValue');
+const logger$8 = debug('app:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -4376,7 +4472,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             parsedValue = JSON.parse(propertyValue);
         }
         catch (error) {
-            logger$7(`${propertyName} value is not a JSON string.`);
+            logger$8(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(propertyValue)) {
             const contentUrl = seedUidToContentUrl.get(propertyValue);
@@ -4392,11 +4488,11 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$7(`${propertyName} value is an array of seedUids`);
+            logger$8(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (Array.isArray(parsedValue)) {
-            logger$7(`${propertyName} value is a stringified array of seedUids`);
+            logger$8(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(propertyValue);
@@ -4775,7 +4871,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                         propertyValue: metadata.propertyValue,
                     })
                         .from(metadata)
-                        .where(and(eq(metadata.seedUid, propertyValueFromDb), eq(metadata.propertyName, 'storageTransactionId')));
+                        .where(and(eq(metadata.seedUid, propertyValueFromDb), or(eq(metadata.propertyName, 'storageTransactionId'), eq(metadata.propertyName, 'transactionId'))));
                     if (storageTransactionQuery && storageTransactionQuery.length > 0) {
                         const row = storageTransactionQuery[0];
                         refResolvedValue = row.propertyValue;
@@ -4836,7 +4932,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await import('./index-Dk6K4W4n.js');
+            const { Item } = await import('./index-CPxn1SR4.js');
             const item = await Item.find({
                 seedLocalId,
                 modelName,
@@ -4881,16 +4977,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$6 = debug('app:write:updateItemPropertyValue');
-const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
-    if (!modelName || (!seedLocalId && !seedUid)) {
-        return;
-    }
-    eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
-};
+const logger$7 = debug('app:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, }) => {
     if (!localId && !seedLocalId) {
-        logger$6(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$7(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -4928,7 +5018,7 @@ const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUi
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$6(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$7(`[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
@@ -4941,7 +5031,6 @@ const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUi
                                            updated_at                 = ${Date.now()}
                                        WHERE local_id = '${localId}';`;
             await appDb.run(sql.raw(updatePropertyStatement));
-            sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
             return;
         }
         const seedDataFromDb = await getSeedData({ seedLocalId });
@@ -4979,7 +5068,6 @@ const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUi
                                           ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
                                           ${Date.now()});`;
         await appDb.run(sql.raw(newPropertyStatement));
-        sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
         return {
             localId: newLocalId,
             schemaUid,
@@ -5028,7 +5116,6 @@ const updateItemPropertyValue = async ({ localId, propertyName, newValue, seedUi
                                         ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
                                         ${Date.now()});`;
     await appDb.run(sql.raw(newPropertyStatement));
-    sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
     return {
         localId: newLocalId,
         schemaUid,
@@ -5145,17 +5232,20 @@ const createMetadata = async (metadataValues, propertyRecordSchema) => {
         const queryClient = BaseQueryClient.getQueryClient();
         const easClient = BaseEasClient.getEasClient();
         const easDataType = INTERNAL_DATA_TYPES[propertyRecordSchema.dataType].eas;
+        const propertyNameSnakeCase = toSnakeCase$1(metadataValues.propertyName);
         const queryResult = await queryClient.fetchQuery({
             queryKey: [`getSchemaByName${metadataValues.propertyName}`],
             queryFn: async () => easClient.request(GET_SCHEMA_BY_NAME, {
                 where: {
                     schema: {
-                        equals: `${easDataType} ${metadataValues.propertyName}`,
+                        equals: `${easDataType} ${propertyNameSnakeCase}`,
                     },
                 },
             }),
         });
-        metadataValues.schemaUid = queryResult.data[0].schema;
+        if (queryResult && queryResult.schemas.length > 0) {
+            metadataValues.schemaUid = queryResult.schemas[0].id;
+        }
     }
     return appDb
         .insert(metadata)
@@ -5325,7 +5415,7 @@ const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
             refSeedType: 'image',
             refSchemaUid: imageSchemaUid,
             renderValue: refResolvedDisplayValue,
-            refResolvedDisplayValue: refResolvedDisplayValue,
+            refResolvedDisplayValue,
             refResolvedValue: fileName,
             localStorageDir: '/images',
             easDataType: 'bytes32',
@@ -5740,7 +5830,7 @@ const getPropertyData$1 = async ({ propertyName, seedLocalId, seedUid, }) => {
 };
 
 var _a$1;
-const logger$5 = debug('app:property:class');
+const logger$6 = debug('app:property:class');
 class BaseItemProperty {
     constructor(initialValues) {
         this._isRelation = false;
@@ -5787,7 +5877,7 @@ class BaseItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$5('List property value is not JSON', e);
+                            logger$6('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -5825,16 +5915,16 @@ class BaseItemProperty {
                 context.localStorageDir) {
                 const filePath = `/files/${context.localStorageDir}/${context.refResolvedValue}`;
                 try {
-                    const exists = await fs$1.promises.exists(filePath);
+                    const exists = await fs.promises.exists(filePath);
                     if (exists) {
-                        renderValue = await fs$1.promises.readFile(filePath, 'utf-8');
+                        renderValue = await fs.promises.readFile(filePath, 'utf-8');
                     }
                     if (!exists) {
                         renderValue = 'No file found';
                     }
                 }
                 catch (e) {
-                    logger$5(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$6(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = 'No file found';
                 }
             }
@@ -5857,12 +5947,13 @@ class BaseItemProperty {
                 return;
             }
             this._subject.next(renderValue);
-            if (context.seedLocalId) {
-                eventEmitter.emit(`item.${modelName}.${context.seedLocalId}.update`);
-            }
-            if (context.seedUid) {
-                eventEmitter.emit(`item.${modelName}.${context.seedUid}.update`);
-            }
+            // TODO: Maybe have this only update the property?
+            // if (context.seedLocalId) {
+            //   eventEmitter.emit(`item.${modelName}.${context.seedLocalId}.update`)
+            // }
+            // if (context.seedUid) {
+            //   eventEmitter.emit(`item.${modelName}.${context.seedUid}.update`)
+            // }
         });
         this._service.start();
     }
@@ -6078,7 +6169,7 @@ const getSegmentedItemProperties = (item) => {
     };
 };
 
-const logger$4 = debug('app:item:getPublishUploads');
+const logger$5 = debug('app:item:getPublishUploads');
 const prepareArweaveTransaction = async (data, contentHash) => {
     const transactionData = {
         data,
@@ -6086,8 +6177,8 @@ const prepareArweaveTransaction = async (data, contentHash) => {
     };
     const tx = await getArweave().createTransaction(transactionData);
     if (contentHash) {
-        logger$4('contentHash', contentHash);
-        logger$4('adding content hash tag to tx.id:', tx.id);
+        logger$5('contentHash', contentHash);
+        logger$5('adding content hash tag to tx.id:', tx.id);
         tx.addTag('Content-SHA-256', contentHash);
     }
     return tx;
@@ -6109,27 +6200,6 @@ const processUploadProperty = async (uploadProperty, uploads, relatedItemPropert
             localStoragePath: filePath,
         });
     }
-    // const filePath = itemProperty.localStoragePath
-    //
-    // if (!filePath) {
-    //   throw new Error(
-    //     `No localStoragePath found for ItemProperty ${itemProperty.propertyName}`,
-    //   )
-    // }
-    //
-    // const exists = await fs.promises.exists(filePath)
-    // if (!exists) {
-    //   throw new Error(`File doesn't exist at ${filePath}`)
-    //
-    //   // const handle = await navigator.storage.getDirectory()
-    //   //
-    //   // await configureSingle({
-    //   //   backend: WebAccess,
-    //   //   handle,
-    //   // })
-    // }
-    //
-    // const mainFileContents = await fs.promises.readFile(filePath)
     let fileContents;
     let transaction;
     if (!childUploads || childUploads.length === 0) {
@@ -6141,12 +6211,6 @@ const processUploadProperty = async (uploadProperty, uploads, relatedItemPropert
             const exists = await fs.promises.exists(filePath);
             if (!exists) {
                 return uploads;
-                // const handle = await navigator.storage.getDirectory()
-                //
-                // await configureSingle({
-                //   backend: WebAccess,
-                //   handle,
-                // })
             }
             try {
                 fileContents = await fs.promises.readFile(filePath);
@@ -6310,7 +6374,7 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData) => {
     }
     return itemPublishData;
 };
-const processRelationProperty = async (relationProperty, multiPublishPayload, uploadedTransactions) => {
+const processRelationProperty = async (relationProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId) => {
     const value = relationProperty.getService().getSnapshot()
         .context.propertyValue;
     if (!value || relationProperty.uid) {
@@ -6336,7 +6400,7 @@ const processRelationProperty = async (relationProperty, multiPublishPayload, up
         listOfAttestations: [],
         propertiesToUpdate: [
             {
-                publishLocalId: relationProperty.localId,
+                publishLocalId: originalSeedLocalId,
                 propertySchemaUid: relationProperty.schemaUid,
             },
         ],
@@ -6356,7 +6420,7 @@ const processRelationProperty = async (relationProperty, multiPublishPayload, up
     multiPublishPayload.push(publishPayload);
     return multiPublishPayload;
 };
-const processListProperty = async (listProperty, multiPublishPayload) => {
+const processListProperty = async (listProperty, multiPublishPayload, originalSeedLocalId) => {
     let value = listProperty.getService().getSnapshot().context.propertyValue;
     if (!value || listProperty.uid) {
         return multiPublishPayload;
@@ -6399,7 +6463,7 @@ const processListProperty = async (listProperty, multiPublishPayload) => {
             listOfAttestations: [],
             propertiesToUpdate: [
                 {
-                    publishLocalId: listProperty.localId,
+                    publishLocalId: originalSeedLocalId,
                     propertySchemaUid: listProperty.schemaUid,
                 },
             ],
@@ -6437,14 +6501,15 @@ const getPublishPayload = async (item, uploadedTransactions) => {
         }
     }
     for (const relationProperty of itemRelationProperties) {
-        multiPublishPayload = await processRelationProperty(relationProperty, multiPublishPayload, uploadedTransactions);
+        multiPublishPayload = await processRelationProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId);
         itemBasicProperties.push(relationProperty);
     }
-    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData);
-    multiPublishPayload.push(itemPublishData);
     for (const listProperty of itemListProperties) {
-        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload);
+        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, item.seedLocalId);
+        itemBasicProperties.push(listProperty);
     }
+    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData);
+    multiPublishPayload.push(itemPublishData);
     return multiPublishPayload;
 };
 
@@ -6559,7 +6624,7 @@ class BaseItem {
                 propertiesObj[transformedKey] = propertyInstance;
             }
             this._propertiesSubject.next(propertiesObj);
-            eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
+            // eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`)
         });
         this._service.start();
         const definedKeys = ['ModelClass'];
@@ -6800,7 +6865,7 @@ const initItem = async () => {
         Item$2 = (await Promise.resolve().then(function () { return Item$1; })).Item;
     }
     if (!isBrowser()) {
-        Item$2 = (await import('./Item-BleJyiA2.js')).Item;
+        Item$2 = (await import('./Item-BmPvgaG4.js')).Item;
     }
 };
 
@@ -6810,17 +6875,17 @@ const initItemProperty = async () => {
         ItemProperty$2 = (await Promise.resolve().then(function () { return ItemProperty$1; })).ItemProperty;
     }
     if (!isBrowser()) {
-        ItemProperty$2 = (await import('./ItemProperty-CH7JmVg-.js')).ItemProperty;
+        ItemProperty$2 = (await import('./ItemProperty-BW4k1h0o.js')).ItemProperty;
     }
 };
 
 let Db;
 const initDb = async () => {
     if (isBrowser()) {
-        Db = (await import('./Db-BEoczaGe.js')).Db;
+        Db = (await import('./Db-5C5VqRWb.js')).Db;
     }
     if (!isBrowser()) {
-        Db = (await import('./Db-Y1GWsyNL.js')).Db;
+        Db = (await import('./Db-Dv890NJZ.js')).Db;
     }
     // TODO: Add config for React Native
 };
@@ -6837,7 +6902,7 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-const logger$3 = debug('app:react:services');
+const logger$4 = debug('app:react:services');
 const finalStrings = ['idle', 'ready', 'done', 'success', 'initialized'];
 const getServiceName = (service) => {
     let name = 'actor';
@@ -6884,7 +6949,7 @@ const getServiceUniqueKey = (service) => {
         snapshot = service.getSnapshot();
     }
     catch (error) {
-        logger$3('Error:', error);
+        logger$4('Error:', error);
         return uniqueKey;
     }
     if (snapshot) {
@@ -7113,7 +7178,7 @@ const useGlobalServiceStatus = () => {
     };
 };
 
-const logger$2 = debug('app:react:item');
+const logger$3 = debug('app:react:item');
 const useItem = ({ modelName, seedLocalId, seedUid }) => {
     // const [itemSubscription, setItemSubscription] = useState<
     //   Subscription | undefined
@@ -7190,7 +7255,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             seedUid,
         });
         if (!foundItem) {
-            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            logger$3('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
             isReadingDb.current = false;
             return;
         }
@@ -7212,7 +7277,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             const subscription = item.subscribe(async (_) => {
                 const newItem = await Item.find({ modelName, seedLocalId, seedUid });
                 if (!newItem) {
-                    logger$2('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    logger$3('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
                     return;
                 }
                 updateItem(newItem);
@@ -7370,8 +7435,13 @@ var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     ItemProperty: ItemProperty
 });
 
-const logger$1 = debug('app:react:property');
-const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
+const logger$2 = debug('app:react:property');
+const useItemProperty = (props = {
+    propertyName: '',
+    seedLocalId: '',
+    seedUid: '',
+}) => {
+    const { propertyName, seedLocalId, seedUid } = props;
     const [property, setProperty] = useState();
     const [isInitialized, setIsInitialized] = useState(false);
     const { internalStatus } = useGlobalServiceStatus();
@@ -7396,7 +7466,7 @@ const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
             seedUid,
         });
         if (!foundProperty) {
-            logger$1(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            logger$2(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
             isReadingDb.current = false;
             return;
         }
@@ -7406,11 +7476,11 @@ const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
         setProperty(foundProperty);
         setIsInitialized(true);
         isReadingDb.current = false;
-    }, [internalStatus]);
+    }, [internalStatus, props]);
     const listenerRef = useRef(readFromDb);
     useEffect(() => {
         listenerRef.current = readFromDb;
-    }, [readFromDb]);
+    }, [readFromDb, props]);
     useEffect(() => {
         if (internalStatus === 'ready') {
             readFromDb();
@@ -7568,10 +7638,10 @@ const withSeed = (config, webpack, isServer) => {
     return config;
 };
 
-const logger = debug('app:services:events');
+const logger$1 = debug('app:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$1(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state));
 };
 const setupServicesEventHandlers = () => {
@@ -7599,33 +7669,40 @@ const setupServiceHandlers = () => {
 
 const initEasClient = async () => {
     if (isBrowser()) {
-        (await import('./EasClient-BjlbuffX.js')).EasClient;
+        (await import('./EasClient-sCbTHcO8.js')).EasClient;
     }
     if (!isBrowser()) {
-        (await import('./EasClient-Cg1q8lBu.js')).EasClient;
+        (await import('./EasClient-CBu9ENAi.js')).EasClient;
     }
 };
 
 const initQueryClient = async () => {
     if (isBrowser()) {
-        (await import('./QueryClient-CDsEencG.js')).QueryClient;
+        (await import('./QueryClient-BBaE-LKI.js')).QueryClient;
     }
     if (!isBrowser()) {
-        (await import('./QueryClient-BKjgZnSt.js')).QueryClient;
+        (await import('./QueryClient-C-ZzUnWq.js')).QueryClient;
     }
 };
 
 const initFileManager = async () => {
     if (isBrowser()) {
-        (await import('./FileManager-D53H3aUS.js')).FileManager;
+        (await import('./FileManager-AhAsy_F_.js')).FileManager;
     }
     if (!isBrowser()) {
-        (await import('./FileManager-t4zcT3NL.js')).FileManager;
+        (await import('./FileManager-COOp89Mj.js')).FileManager;
     }
 };
 
+const logger = debug('app:client');
 const client = {
+    isInitialized: false,
     init: async (options) => {
+        logger('init client');
+        if (client.isInitialized) {
+            return;
+        }
+        client.isInitialized = true;
         const { config, addresses } = options;
         await initItem();
         await initItemProperty();
@@ -7659,7 +7736,7 @@ const client = {
             arweaveDomain,
             filesDir,
         });
-        const { models: internalModels } = await import('./seed.schema.config-DdCq87m_.js');
+        const { models: internalModels } = await import('./seed.schema.config-BXWvwsZQ.js');
         for (const [key, value] of Object.entries(internalModels)) {
             setModel(key, value);
         }
@@ -7707,4 +7784,4 @@ const client = {
 enableMapSet();
 
 export { BaseItem as B, Db as D, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, BaseItemProperty as a, BaseDb as b, ImageSrc as c, Item$2 as d, ItemProperty$2 as e, useItem as f, useItemProperties as g, useCreateItem as h, useItemProperty as i, useDeleteItem as j, useGlobalServiceStatus as k, usePublishItem as l, usePersistedSnapshots as m, useServices as n, useService as o, getCorrectId as p, getGlobalService as q, eventEmitter as r, saveAppState as s, withSeed as t, useItems as u, client as v, waitForFile as w };
-//# sourceMappingURL=index-DanGFTTF.js.map
+//# sourceMappingURL=index-CGeSKilQ.js.map