@seedprotocol/sdk 0.4.21 → 0.4.23

package/dist/{index-BrD_NNaX.js → index-18lln0cM.js}

@@ -1,4 +1,4 @@
-import { waitFor, fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
+import { waitFor, fromCallback, fromPromise, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
 import { sqliteTable, integer, text, unique, int, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
 import { relations, and, eq, isNull, isNotNull, not, or, max, count, getTableColumns, sql, desc, inArray, gt } from 'drizzle-orm';
 import { customAlphabet } from 'nanoid';
@@ -8,9 +8,8 @@ import { ZeroAddress, getAddress } from 'ethers';
 import pluralize from 'pluralize';
 import { Type } from '@sinclair/typebox';
 import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
-import { upperFirst, camelCase, startCase, orderBy, throttle } from 'lodash-es';
+import { upperFirst, camelCase, startCase, throttle, orderBy } from 'lodash-es';
 import { BehaviorSubject } from 'rxjs';
-import EventEmitter from 'eventemitter3';
 import 'arweave';
 import * as sha3 from 'js-sha3';
 
@@ -157,6 +156,13 @@ class BaseFileManager {
     static downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions, }) {
         return this.PlatformClass.downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions });
     }
+    static downloadFileByTransactionId({ transactionId, arweaveHost, excludedTransactions, }) {
+        return this.PlatformClass.downloadAllFiles({
+            transactionIds: [transactionId],
+            arweaveHost,
+            excludedTransactions,
+        });
+    }
     static resizeImage({ filePath, width, height }) {
         return this.PlatformClass.resizeImage({ filePath, width, height });
     }
@@ -365,12 +371,71 @@ var SeedModels;
 // Internal SDK schema that should not be created in app's files directory
 const SEED_PROTOCOL_SCHEMA_NAME = 'Seed Protocol';
 const INTERNAL_SCHEMA_IDS = ['SEEDPROTOCOL'];
-/** Default Arweave gateway host used across all packages */
-const DEFAULT_ARWEAVE_HOST = 'arweave.net';
+/** Default Arweave gateway host used across all packages (first in {@link DEFAULT_ARWEAVE_GATEWAYS}) */
+const DEFAULT_ARWEAVE_HOST = 'ar.seedprotocol.io';
 /** Default Arweave gateway GraphQL endpoint (transaction / block queries). */
-const DEFAULT_ARWEAVE_GRAPHQL_URL = 'https://arweave.net/graphql';
-/** Default Arweave gateways for fallback / metadata fetching (ordered by preference) */
-const DEFAULT_ARWEAVE_GATEWAYS = ['arweave.net', 'ar-io.net'];
+const DEFAULT_ARWEAVE_GRAPHQL_URL = `https://${DEFAULT_ARWEAVE_HOST}/graphql`;
+/**
+ * Default Arweave gateways for read fallback / metadata fetching (ordered by preference).
+ * Override order with `ARWEAVE_READ_GATEWAYS` or `NEXT_PUBLIC_ARWEAVE_READ_GATEWAYS` (comma-separated hosts).
+ */
+const DEFAULT_ARWEAVE_GATEWAYS = ['ar.seedprotocol.io', 'arweave.net', 'arweave.dev', 'g8way.io', 'permagate.io', 'zigza.xyz',];
+const READ_GATEWAYS_ENV_KEYS = ['ARWEAVE_READ_GATEWAYS', 'NEXT_PUBLIC_ARWEAVE_READ_GATEWAYS'];
+/** Ordered gateway hostnames for reads: env list if set, otherwise {@link DEFAULT_ARWEAVE_GATEWAYS}. */
+function getDefaultArweaveReadGatewayHostsOrdered() {
+    if (typeof process === 'undefined' || !process.env) {
+        return [...DEFAULT_ARWEAVE_GATEWAYS];
+    }
+    for (const key of READ_GATEWAYS_ENV_KEYS) {
+        const raw = process.env[key]?.trim();
+        if (raw) {
+            return raw.split(',').map((s) => s.trim()).filter(Boolean);
+        }
+    }
+    return [...DEFAULT_ARWEAVE_GATEWAYS];
+}
+/**
+ * Deduped host list: primary first, then each default not already present (case-insensitive).
+ */
+function mergePrimaryHostWithDefaults(primary, defaults) {
+    const seen = new Set();
+    const out = [];
+    const keyOf = (h) => h.trim().toLowerCase().replace(/\/$/, '');
+    const add = (h) => {
+        const t = h.trim().replace(/\/$/, '');
+        if (!t)
+            return;
+        const k = keyOf(t);
+        if (seen.has(k))
+            return;
+        seen.add(k);
+        out.push(t);
+    };
+    add(primary);
+    for (const d of defaults)
+        add(d);
+    return out;
+}
+/**
+ * True if `hostname` looks like a public Arweave gateway used in stored URLs (hydration / RSS).
+ */
+function isKnownArweaveGatewayHostname(hostname) {
+    const h = hostname.trim().toLowerCase();
+    if (!h)
+        return false;
+    if (h.endsWith('arweave.net'))
+        return true;
+    if (h.endsWith('ar-io.net'))
+        return true;
+    for (const g of DEFAULT_ARWEAVE_GATEWAYS) {
+        const gl = g.toLowerCase();
+        if (h === gl || h.endsWith(`.${gl}`))
+            return true;
+    }
+    return false;
+}
+/** Fired after `syncDbWithEas` persists EAS seeds/versions/metadata to SQLite (see `Item.rehydrateCachedItemsFromDbAfterEasSync`). */
+const EAS_SEED_DATA_SYNCED_TO_DB_EVENT = 'easSeedDataSyncedToDb';
 /**
  * Check if a schema is an internal SDK schema that should not be created in app files
  */
@@ -385,6 +450,7 @@ var constants = /*#__PURE__*/Object.freeze({
     DEFAULT_ARWEAVE_GATEWAYS: DEFAULT_ARWEAVE_GATEWAYS,
     DEFAULT_ARWEAVE_GRAPHQL_URL: DEFAULT_ARWEAVE_GRAPHQL_URL,
     DEFAULT_ARWEAVE_HOST: DEFAULT_ARWEAVE_HOST,
+    EAS_SEED_DATA_SYNCED_TO_DB_EVENT: EAS_SEED_DATA_SYNCED_TO_DB_EVENT,
     INIT_SCRIPT_SUCCESS_MESSAGE: INIT_SCRIPT_SUCCESS_MESSAGE,
     INTERNAL_DATA_TYPES: INTERNAL_DATA_TYPES,
     INTERNAL_PROPERTY_NAMES: INTERNAL_PROPERTY_NAMES,
@@ -402,7 +468,10 @@ var constants = /*#__PURE__*/Object.freeze({
     ZERO_BYTES: ZERO_BYTES,
     ZERO_BYTES32: ZERO_BYTES32,
     defaultAttestationData: defaultAttestationData,
-    isInternalSchema: isInternalSchema
+    getDefaultArweaveReadGatewayHostsOrdered: getDefaultArweaveReadGatewayHostsOrdered,
+    isInternalSchema: isInternalSchema,
+    isKnownArweaveGatewayHostname: isKnownArweaveGatewayHostname,
+    mergePrimaryHostWithDefaults: mergePrimaryHostWithDefaults
 });
 
 function parseGateway(input) {
@@ -419,6 +488,8 @@ function parseGateway(input) {
 let _host = DEFAULT_ARWEAVE_HOST;
 let _protocol = 'https';
 let _hostExplicitlySet = false;
+/** When true, production `ARWEAVE_HOST` / `NEXT_PUBLIC_ARWEAVE_HOST` does not override `_host` (after a successful read-gateway probe). */
+let _suppressEnvGatewayOverride = false;
 class BaseArweaveClient {
     static setPlatformClass(platformClass) {
         this.PlatformClass = platformClass;
@@ -431,7 +502,7 @@ class BaseArweaveClient {
             const envHost = typeof process !== 'undefined' && process.env
                 ? process.env.NEXT_PUBLIC_ARWEAVE_HOST || process.env.ARWEAVE_HOST
                 : undefined;
-            if (envHost && !_hostExplicitlySet) {
+            if (envHost && !_hostExplicitlySet && !_suppressEnvGatewayOverride) {
                 return parseGateway(envHost);
             }
         }
@@ -469,6 +540,39 @@ class BaseArweaveClient {
         _host = parsed.host;
         _protocol = parsed.protocol;
         _hostExplicitlySet = true;
+        _suppressEnvGatewayOverride = false;
+    }
+    /**
+     * When true, read-path gateway probing does not change the host ({@link setHost}).
+     */
+    static isReadGatewayLocked() {
+        return _hostExplicitlySet;
+    }
+    /**
+     * @internal Clears env override suppression after probing (for test isolation).
+     */
+    static resetReadGatewaySelectionStateForTests() {
+        _suppressEnvGatewayOverride = false;
+    }
+    /**
+     * Sets the preferred read gateway without locking. Production env host still takes precedence until a probe applies a host.
+     * Used for seed `arweaveDomain`.
+     */
+    static setPreferredReadGateway(host) {
+        const parsed = parseGateway(host);
+        _host = parsed.host;
+        _protocol = parsed.protocol;
+        _hostExplicitlySet = false;
+    }
+    /**
+     * Applies a gateway chosen by read-path health probing so {@link getHost} uses it instead of env override.
+     */
+    static applyProbedReadGateway(host) {
+        const parsed = parseGateway(host);
+        _host = parsed.host;
+        _protocol = parsed.protocol;
+        _hostExplicitlySet = false;
+        _suppressEnvGatewayOverride = true;
     }
     /**
      * Get the GraphQL endpoint URL
@@ -552,6 +656,11 @@ class BaseArweaveClient {
     }
 }
 
+var BaseArweaveClient$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BaseArweaveClient: BaseArweaveClient
+});
+
 /**
  * Trim and strip a trailing slash from an upload API base URL.
  */
@@ -603,6 +712,126 @@ async function getUploadPipelineTransactionStatus(uploadApiBaseUrl, txOrDataItem
     }
 }
 
+const READ_GATEWAY_CACHE_TTL_MS = 3 * 60 * 1000;
+const PROBE_TIMEOUT_MS = 5000;
+let readGatewayCache = null;
+let ensureInFlight = null;
+/** Clears cached read gateway (e.g. after tests or to force a fresh probe). */
+function invalidateReadGatewayCache() {
+    readGatewayCache = null;
+    ensureInFlight = null;
+}
+/** Clears probe cache, env override suppression, and preferred host (for tests). */
+function resetArweaveReadGatewayForTests() {
+    invalidateReadGatewayCache();
+    BaseArweaveClient.resetReadGatewaySelectionStateForTests();
+    if (!BaseArweaveClient.isReadGatewayLocked()) {
+        BaseArweaveClient.setPreferredReadGateway(DEFAULT_ARWEAVE_HOST);
+    }
+}
+/**
+ * GET /info with timeout. Treat 2xx + JSON object as healthy.
+ */
+async function probeGateway(baseUrl, signal) {
+    const url = `${baseUrl.replace(/\/$/, '')}/info`;
+    let timer;
+    const controller = new AbortController();
+    const effectiveSignal = signal ?? controller.signal;
+    if (!signal) {
+        timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    }
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            signal: effectiveSignal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok)
+            return false;
+        const text = await response.text();
+        if (!text.trim())
+            return false;
+        try {
+            const json = JSON.parse(text);
+            return typeof json === 'object' && json !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function selectFirstHealthyReadGateway(hosts, protocol = 'https', signal) {
+    for (const host of hosts) {
+        const h = host.trim().replace(/\/$/, '');
+        if (!h)
+            continue;
+        const baseUrl = `${protocol}://${h}`;
+        if (await probeGateway(baseUrl, signal)) {
+            return h;
+        }
+    }
+    return null;
+}
+function buildOrderedHostsForProbe() {
+    const primary = BaseArweaveClient.getHost();
+    const defaults = getDefaultArweaveReadGatewayHostsOrdered();
+    return mergePrimaryHostWithDefaults(primary, defaults);
+}
+/**
+ * Probes gateways in order and applies the first healthy host via {@link BaseArweaveClient.applyProbedReadGateway}.
+ * No-op when the read gateway is locked ({@link BaseArweaveClient.setHost}).
+ * Uses a short TTL cache to avoid probing on every read.
+ */
+async function ensureReadGatewaySelected(signal) {
+    if (BaseArweaveClient.isReadGatewayLocked()) {
+        return BaseArweaveClient.getHost();
+    }
+    const now = Date.now();
+    if (readGatewayCache && now < readGatewayCache.expiresAt) {
+        return readGatewayCache.host;
+    }
+    if (ensureInFlight) {
+        return ensureInFlight;
+    }
+    ensureInFlight = (async () => {
+        const ordered = buildOrderedHostsForProbe();
+        const protocol = BaseArweaveClient.getProtocol();
+        const picked = await selectFirstHealthyReadGateway(ordered, protocol, signal);
+        if (!BaseArweaveClient.isReadGatewayLocked()) {
+            if (picked) {
+                BaseArweaveClient.applyProbedReadGateway(picked);
+            }
+        }
+        readGatewayCache = {
+            host: BaseArweaveClient.getHost(),
+            expiresAt: Date.now() + READ_GATEWAY_CACHE_TTL_MS,
+        };
+        return readGatewayCache.host;
+    })();
+    try {
+        return await ensureInFlight;
+    }
+    finally {
+        ensureInFlight = null;
+    }
+}
+
+var selectReadGateway = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ensureReadGatewaySelected: ensureReadGatewaySelected,
+    invalidateReadGatewayCache: invalidateReadGatewayCache,
+    probeGateway: probeGateway,
+    resetArweaveReadGatewayForTests: resetArweaveReadGatewayForTests,
+    selectFirstHealthyReadGateway: selectFirstHealthyReadGateway
+});
+
 const GATEWAY_TX_QUERY = `
   query ArweaveGatewayTransaction($id: String!) {
     transaction(id: $id) {
@@ -699,6 +928,42 @@ async function queryArweaveGatewayTransaction(graphqlUrl, dataItemId, init) {
         return null;
     }
 }
+/**
+ * Resolves GraphQL against the first healthy gateway (GET /info probe per host), then runs
+ * {@link queryArweaveGatewayTransaction}. Host order: optional `graphqlUrl` hostname first, then
+ * {@link getDefaultArweaveReadGatewayHostsOrdered}.
+ */
+async function queryArweaveGatewayTransactionWithFallback(graphqlUrl, dataItemId, init) {
+    const defaults = getDefaultArweaveReadGatewayHostsOrdered();
+    const trimmed = graphqlUrl?.trim();
+    let protocol = 'https';
+    let preferredHost = null;
+    if (trimmed) {
+        try {
+            const u = new URL(trimmed);
+            protocol = u.protocol === 'http:' ? 'http' : 'https';
+            preferredHost = u.hostname || null;
+        }
+        catch {
+            preferredHost = null;
+        }
+    }
+    const ordered = preferredHost && preferredHost.length > 0
+        ? mergePrimaryHostWithDefaults(preferredHost, defaults)
+        : [...defaults];
+    const signal = init?.signal;
+    for (const host of ordered) {
+        const base = `${protocol}://${host}`;
+        if (!(await probeGateway(base, signal ?? undefined)))
+            continue;
+        const gqlUrl = `${protocol}://${host}/graphql`;
+        const result = await queryArweaveGatewayTransaction(gqlUrl, dataItemId, init);
+        if (result !== null) {
+            return result;
+        }
+    }
+    return null;
+}
 
 class BaseEasClient {
     static setPlatformClass(platformClass) {
@@ -1374,6 +1639,19 @@ const arweaveL1FinalizeJobs = sqliteTable('arweave_l1_finalize_jobs', {
     dataItemIdUnique: uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
 }));
 
+const easSyncProcesses = sqliteTable('eas_sync_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed'
+    startedAt: int('started_at').notNull(),
+    completedAt: int('completed_at'),
+    requestPayload: text('request_payload').notNull(),
+    errorMessage: text('error_message'),
+    errorDetails: text('error_details'),
+    persistedSnapshot: text('persisted_snapshot').notNull(),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
 /**
  * Links Image seeds materialized from Html `data:image/*` URIs to the parent Item seed for co-publish.
  * Rows are removed after a successful publish (see clearHtmlEmbeddedImageCoPublishRows).
@@ -1864,6 +2142,7 @@ var index = /*#__PURE__*/Object.freeze({
     capitalizeFirstLetter: capitalizeFirstLetter,
     classifyMediaRef: classifyMediaRef,
     convertTxIdToImage: convertTxIdToImage,
+    ensureReadGatewaySelected: ensureReadGatewaySelected,
     generateId: generateId,
     getAlternatePropertyNameForInstanceLookup: getAlternatePropertyNameForInstanceLookup,
     getArweaveUploadStatus: getArweaveUploadStatus,
@@ -1883,6 +2162,7 @@ var index = /*#__PURE__*/Object.freeze({
     getUploadExecutor: getUploadExecutor,
     getUploadPipelineTransactionStatus: getUploadPipelineTransactionStatus,
     identifyString: identifyString,
+    invalidateReadGatewayCache: invalidateReadGatewayCache,
     isArweaveL1AnchoringComplete: isArweaveL1AnchoringComplete,
     isBinary: isBinary,
     isPlaceholderUid: isPlaceholderUid,
@@ -1895,11 +2175,15 @@ var index = /*#__PURE__*/Object.freeze({
     normalizeUploadApiBaseUrl: normalizeUploadApiBaseUrl,
     parseEasRelationPropertyName: parseEasRelationPropertyName,
     pickLatestPropertyAttestationsByRefAndSchema: pickLatestPropertyAttestationsByRefAndSchema,
+    probeGateway: probeGateway,
     queryArweaveGatewayTransaction: queryArweaveGatewayTransaction,
+    queryArweaveGatewayTransactionWithFallback: queryArweaveGatewayTransactionWithFallback,
+    resetArweaveReadGatewayForTests: resetArweaveReadGatewayForTests,
     resolveMediaRef: resolveMediaRef,
     resolveMetadataRecord: resolveMetadataRecord,
     resolveSeedIdsFromRefString: resolveSeedIdsFromRefString,
     resolveStorageNameToSchemaName: resolveStorageNameToSchemaName,
+    selectFirstHealthyReadGateway: selectFirstHealthyReadGateway,
     setAdditionalSyncAddresses: setAdditionalSyncAddresses,
     setGetPublisherForNewSeeds: setGetPublisherForNewSeeds,
     setRevokeExecutor: setRevokeExecutor,
@@ -1922,7 +2206,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-DWtv9fQr.js');
+        const mod = await import('./ModelProperty-D6JLRqQW.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -2106,7 +2390,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_0 = await import('./Schema-CqqcEexA.js');
+            const _mod_0 = await import('./Schema-B5_B8nM5.js');
             const _ns_0 = _mod_0.b;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -2352,7 +2636,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_1 = await import('./Schema-CqqcEexA.js');
+            const _mod_1 = await import('./Schema-B5_B8nM5.js');
             const _ns_1 = _mod_1.b;
             const schemaMod = _ns_1;
             const { Schema } = schemaMod;
@@ -2398,10 +2682,10 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
+            const validationServiceMod = await import('./SchemaValidationService-DXYRdSYa.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_2 = await import('./Schema-CqqcEexA.js');
+            const _mod_2 = await import('./Schema-B5_B8nM5.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -2513,7 +2797,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$r(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-DWtv9fQr.js');
+        const mod = await import('./ModelProperty-D6JLRqQW.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$r('ModelProperty not available from dynamic import');
@@ -2617,7 +2901,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$q(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXYRdSYa.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -2635,7 +2919,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$q(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_3 = await import('./Schema-CqqcEexA.js');
+                            const _mod_3 = await import('./Schema-B5_B8nM5.js');
                             const _ns_3 = _mod_3.b;
                             const schemaMod = _ns_3;
                             const { Schema } = schemaMod;
@@ -2673,7 +2957,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXYRdSYa.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -2688,7 +2972,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_4 = await import('./Schema-CqqcEexA.js');
+                            const _mod_4 = await import('./Schema-B5_B8nM5.js');
                             const _ns_4 = _mod_4.b;
                             const schemaMod = _ns_4;
                             const { Schema } = schemaMod;
@@ -2719,7 +3003,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
+                const validationServiceMod = await import('./SchemaValidationService-DXYRdSYa.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -4671,7 +4955,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-DWtv9fQr.js');
+                    const mod = await import('./ModelProperty-D6JLRqQW.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -5051,7 +5335,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-DWtv9fQr.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-D6JLRqQW.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5354,6 +5638,7 @@ const ENV = (typeof process !== 'undefined' && process.env)
 var MachineIds;
 (function (MachineIds) {
     MachineIds["CLIENT_MANAGER"] = "@seedSdk/clientManager";
+    MachineIds["EAS_SYNC_MANAGER"] = "@seedSdk/easSyncManager";
     MachineIds["GLOBAL"] = "@seedSdk/global";
     MachineIds["INTERNAL"] = "@seedSdk/internal";
     MachineIds["EAS"] = "@seedSdk/eas";
@@ -5426,7 +5711,7 @@ const EAS_ENDPOINT = ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
  * This constant is kept for backward compatibility but will be removed in a future version.
  * Migration: import { BaseArweaveClient } from '@/helpers' and use BaseArweaveClient.getHost()
  */
-ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'arweave.net';
+ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'ar.seedprotocol.io';
 
 debug('seedSdk:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
@@ -6347,7 +6632,7 @@ const getMetadataLatest = ({ seedLocalId, seedUid }) => {
         rowNum: sql.raw(`
            ROW_NUMBER() OVER (
                PARTITION BY property_name 
-               ORDER BY COALESCE(attestation_created_at, created_at) DESC
+               ORDER BY COALESCE(attestation_created_at, created_at) DESC, local_id DESC
            )
           `).as('rowNum')
     })
@@ -6360,6 +6645,25 @@ var metadataLatest = /*#__PURE__*/Object.freeze({
     getMetadataLatest: getMetadataLatest
 });
 
+/**
+ * Canonical "latest metadata row first" ordering. Must stay in sync with SQL that uses:
+ * `ORDER BY COALESCE(attestation_created_at, created_at) DESC, local_id DESC`
+ */
+function metadataLatestFirstSortKey(row) {
+    return {
+        t: row.attestationCreatedAt ?? row.createdAt ?? 0,
+        localId: String(row.localId ?? ''),
+    };
+}
+/** Sort comparator: larger time first; on tie, larger localId (lexicographic) first. */
+function compareMetadataRowsLatestFirst(a, b) {
+    const ka = metadataLatestFirstSortKey(a);
+    const kb = metadataLatestFirstSortKey(b);
+    if (kb.t !== ka.t)
+        return kb.t - ka.t;
+    return kb.localId.localeCompare(ka.localId);
+}
+
 const logger$l = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
@@ -6401,9 +6705,8 @@ function pickBetterMetadataRowForSameInstance(a, b) {
         return b;
     if (sa !== sb)
         return sa > sb ? a : b;
-    const ta = a.attestationCreatedAt ?? a.createdAt ?? 0;
-    const tb = b.attestationCreatedAt ?? b.createdAt ?? 0;
-    return ta >= tb ? a : b;
+    const cmp = compareMetadataRowsLatestFirst(a, b);
+    return cmp < 0 ? a : b;
 }
 function dedupeMetadataRowsByInstanceKey(metadataRows, propertySchemas) {
     const byKey = new Map();
@@ -6451,7 +6754,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_5 = await import('./Schema-CqqcEexA.js');
+                    const _mod_5 = await import('./Schema-B5_B8nM5.js');
                     const _ns_5 = _mod_5.b;
                     const { Schema } = _ns_5;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -6502,7 +6805,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-Cqf_DxkJ.js');
+                const schemaMod = await import('./index-DB3nZ0lK.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -6549,7 +6852,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-Cqf_DxkJ.js');
+                    const schemaMod = await import('./index-DB3nZ0lK.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6806,9 +7109,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-DS2dQ4Ho.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CH72lAID.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-DpYwi-rd.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-DEdHgrgC.js');
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -7154,6 +7457,11 @@ const getSeedData = async ({ seedLocalId, seedUid }) => {
     return rows[0];
 };
 
+var getSeedData$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getSeedData: getSeedData
+});
+
 /**
  * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
  * Skips legacy 'NULL' / ZERO_BYTES32 placeholders and non-bytes32 strings.
@@ -7643,7 +7951,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cqf_DxkJ.js');
+        const schemaMod = await import('./index-DB3nZ0lK.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -8006,155 +8314,826 @@ function parseListPropertyValueFromStorage(raw) {
     return trimmed.split(',').map((s) => s.trim()).filter(Boolean);
 }
 
-// Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
-// import { ModelPropertyDataTypes } from '@/schema'
-const logger$g = debug('seedSdk:property:actors:hydrateFromDb');
-const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
-    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
-    if (!propertyNameRaw) {
-        throw new Error('propertyName is required');
+class SeedEventEmitter {
+    constructor() {
+        this.listeners = new Map();
     }
-    let propertyName = propertyNameRaw;
-    // Note: isRelation, isImage, isFile checks moved inside async function
-    // to use dynamically imported ModelPropertyDataTypes
-    const _hydrateFromDb = async () => {
-        // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cqf_DxkJ.js');
-        const { ModelPropertyDataTypes } = schemaMod;
-        const appDb = BaseDb.getAppDb();
-        const whereClauses = [];
-        // Re-check types with dynamically imported ModelPropertyDataTypes
-        // Use normalizeDataType for case-insensitive comparison (schema may use "image" vs "Image")
-        const normalizedDataType = normalizeDataType(propertyRecordSchema?.dataType);
-        const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
-        propertyRecordSchema &&
-            propertyRecordSchema.ref &&
-            normalizedDataType === ModelPropertyDataTypes.Relation;
-        const isImageDynamic = propertyRecordSchema &&
-            (normalizedDataType === ModelPropertyDataTypes.Image ||
-                normalizedRefValueType === ModelPropertyDataTypes.Image);
-        propertyRecordSchema &&
-            normalizedDataType === ModelPropertyDataTypes.File;
-        const isHtmlDynamic = propertyRecordSchema &&
-            normalizedDataType === ModelPropertyDataTypes.Html;
-        // Html/Image/File/Relation store metadata with Id suffix (e.g. htmlId); query both variants
-        const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
-        whereClauses.push(propertyNames.length > 1
-            ? or(...propertyNames.map((n) => eq(metadata$1.propertyName, n)))
-            : eq(metadata$1.propertyName, propertyNames[0]));
-        if (seedUid) {
-            whereClauses.push(eq(metadata$1.seedUid, seedUid));
-        }
-        if (seedLocalId) {
-            whereClauses.push(eq(metadata$1.seedLocalId, seedLocalId));
-        }
-        const rows = await appDb
-            .select()
-            .from(metadata$1)
-            .where(and(...whereClauses))
-            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'));
-        if (!rows || !rows.length) {
-            return;
-        }
-        const firstRow = rows[0];
-        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, } = firstRow;
-        let { refResolvedDisplayValue, refResolvedValue, localStorageDir } = firstRow;
-        let propertyValueProcessed = propertyValueFromDb;
-        // Image: always resolve display value from file (blob URLs in DB are invalid after reload)
-        if (isImageDynamic) {
-            let dir = localStorageDir;
-            if (!dir && isImageDynamic) {
-                dir = 'images';
-            }
-            dir = dir.replace(/^\//, '');
-            if (propertyValueFromDb &&
-                propertyValueFromDb.length === 66) {
-                // Here the storageTransactionId is stored on a different record and
-                // we want to add it as the refResolvedValue
-                const storageTransactionQuery = await appDb
-                    .select({
-                    propertyValue: metadata$1.propertyValue,
-                })
-                    .from(metadata$1)
-                    .where(and(eq(metadata$1.seedUid, propertyValueFromDb), or(eq(metadata$1.propertyName, 'storageTransactionId'), eq(metadata$1.propertyName, 'transactionId'))));
-                if (storageTransactionQuery && storageTransactionQuery.length > 0) {
-                    const row = storageTransactionQuery[0];
-                    refResolvedValue = row.propertyValue;
-                    await updateMetadata({
-                        localId,
-                        refResolvedValue,
-                        localStorageDir: '/images',
-                    });
-                }
-            }
-            if (refResolvedValue) {
-                try {
-                    const dirPath = BaseFileManager.getFilesPath(dir);
-                    const dirExists = await BaseFileManager.pathExists(dirPath);
-                    if (dirExists) {
-                        const fs = await BaseFileManager.getFs();
-                        const path = BaseFileManager.getPathModule();
-                        const files = await fs.promises.readdir(dirPath);
-                        const matchingFiles = files.filter((file) => {
-                            return path.basename(file).includes(refResolvedValue);
-                        });
-                        let fileExists = false;
-                        let filename;
-                        let filePath;
-                        if (matchingFiles && matchingFiles.length > 0) {
-                            fileExists = true;
-                            filename = matchingFiles[0];
-                            filePath = BaseFileManager.getFilesPath(dir, filename);
-                        }
-                        localStorageDir = `/${dir}`;
-                        if (fileExists && filename && filePath) {
-                            const file = await BaseFileManager.readFile(filePath);
-                            refResolvedDisplayValue = URL.createObjectURL(file);
-                            // Do not persist blob URL - it is session-scoped
-                        }
-                    }
-                }
-                catch (e) {
-                    logger$g('[hydrateFromDb] Image file resolution error', e);
-                }
-            }
-        }
-        if (propertyRecordSchema &&
-            normalizedDataType === ModelPropertyDataTypes.List &&
-            typeof propertyValueFromDb === 'string') {
-            propertyValueProcessed = parseListPropertyValueFromStorage(propertyValueFromDb);
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return this;
+        set.delete(listener);
+        if (set.size === 0)
+            this.listeners.delete(event);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (typeof event === 'undefined') {
+            this.listeners.clear();
+            return this;
+        }
+        this.listeners.delete(event);
+        return this;
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return false;
+        for (const listener of [...set]) {
+            listener(...args);
         }
-        sendBack({
-            type: 'updateContext',
-            localId,
-            uid,
-            propertyValue: propertyValueProcessed,
-            seedLocalId: seedLocalIdFromDb,
-            seedUid: seedUidFromDb,
-            versionLocalId: versionLocalIdFromDb,
-            versionUid: versionUidFromDb,
-            schemaUid: schemaUidFromDb,
-            refValueType,
-            localStorageDir,
-            refResolvedValue,
-            refResolvedDisplayValue,
-            renderValue: refResolvedDisplayValue,
-            populatedFromDb: true,
-        });
-        if (propertyRecordSchema &&
-            propertyRecordSchema.storageType &&
-            propertyRecordSchema.storageType === 'ItemStorage') {
-            const itemMod = await Promise.resolve().then(function () { return Item$1; });
-            const { Item } = itemMod;
-            const item = await Item.find({
-                seedLocalId: seedLocalId ?? undefined,
-                modelName,
-            });
-            if (item) {
-                const dir = localStorageDir?.replace(/^\//, '') || 'files';
-                const filePath = BaseFileManager.getFilesPath(dir, refResolvedValue);
-                const exists = await BaseFileManager.pathExists(filePath);
-                if (!exists) {
+        return true;
+    }
+}
+const eventEmitter = new SeedEventEmitter();
+
+const GET_FILES_METADATA = graphql(/* GraphQL */ `
+  query GetFilesMetadata($where: AttestationWhereInput!) {
+    filesMetadata: attestations(
+      where: $where
+      orderBy: [{ timeCreated: desc }]
+    ) {
+      ...attestationFields
+    }
+  }
+`);
+
+const getMetadata = async (props) => {
+    const appDb = BaseDb.getAppDb();
+    let storageTransactionId;
+    if (props) {
+        storageTransactionId = props.storageTransactionId;
+    }
+    const whereClauses = [];
+    if (storageTransactionId) {
+        whereClauses.push(eq(metadata$1.propertyName, 'storageTransactionId'));
+        whereClauses.push(eq(metadata$1.propertyValue, storageTransactionId));
+    }
+    const metadataRows = await appDb
+        .select()
+        .from(metadata$1)
+        .where(and(...whereClauses));
+    if (!metadataRows || metadataRows.length === 0) {
+        return;
+    }
+    return metadataRows[0];
+};
+
+const saveMetadata = async (metadataRecord, metadataValues) => {
+    if (!metadataRecord.localId) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    await appDb
+        .update(metadata$1)
+        .set({
+        ...metadataValues,
+        updatedAt: Date.now(),
+    })
+        .where(eq(metadata$1.localId, metadataRecord.localId));
+};
+
+const isNode = () => {
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
+};
+const isBrowser = () => {
+    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
+};
+const isElectron = () => {
+    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
+};
+/**
+ * Detects if code is running in an Electron renderer process.
+ *
+ * Uses multiple detection methods for robustness:
+ * 1. Checks process.type === 'renderer' (most reliable)
+ * 2. Falls back to checking if Electron is present and window/document exist
+ *
+ * @returns true if running in Electron renderer process, false otherwise
+ */
+const isElectronRenderer = () => {
+    // Method 1: Check process.type (most reliable - official Electron API)
+    if (typeof process !== 'undefined' &&
+        process.type === 'renderer') {
+        return true;
+    }
+    // Method 2: Fallback - Electron + browser-like environment
+    // Renderer processes have window/document, main process doesn't (in modern Electron)
+    if (isElectron() &&
+        typeof window !== 'undefined' &&
+        typeof document !== 'undefined') {
+        return true;
+    }
+    return false;
+};
+/**
+ * True where OPFS-backed Arweave file downloads should run: normal browsers and
+ * Electron renderer. {@link isBrowser} is false for every Electron build (including renderer).
+ */
+const supportsOpfsFileDownloads = () => {
+    return isBrowser() || isElectronRenderer();
+};
+
+const logger$g = debug('seedSdk:files:download');
+const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
+/** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
+const GET_FILES_METADATA_STALE_MS = 120000;
+let bulkDownloadInFlight = null;
+const lazyDownloadInFlightByTransactionId = new Map();
+// syncDbFiles helper - internal service removed, functionality moved here
+const syncDbFiles = async (endpoints) => {
+    // TODO: Implement syncDbFiles functionality if needed
+    // This was previously in @/services/internal/helpers
+    logger$g('[download] syncDbFiles called but not yet implemented');
+    return Promise.resolve();
+};
+const getAppDbReady = async () => {
+    if (!BaseDb.isAppDbReady()) {
+        // Wait for ClientManager to be ready (DB_INIT state or later)
+        const clientManagerMod = await Promise.resolve().then(function () { return ClientManager$1; });
+        const { getClient } = clientManagerMod;
+        const clientManager = getClient();
+        const clientService = clientManager.getService();
+        await waitFor(clientService, (snapshot) => {
+            const state = snapshot.value;
+            return state === 'dbInit' ||
+                state === 'saveConfig' ||
+                state === 'processSchemaFiles' ||
+                state === 'addModelsToStore' ||
+                state === 'addModelsToDb' ||
+                state === 'idle';
+        }, { timeout: 30000 });
+    }
+    return BaseDb.getAppDb();
+};
+const getExcludedTransactions = async () => {
+    const appDb = await getAppDbReady();
+    if (!appDb) {
+        return new Set();
+    }
+    const excludedTransactionsQuery = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'excludedTransactions'));
+    const excludedTransactions = new Set();
+    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
+        const valueString = excludedTransactionsQuery[0].value;
+        if (valueString) {
+            const excludedTransactionsArray = JSON.parse(valueString);
+            for (const txId of excludedTransactionsArray) {
+                excludedTransactions.add(txId);
+            }
+        }
+    }
+    return excludedTransactions;
+};
+/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
+const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
+const normalizeArweaveTxId = (raw) => {
+    if (raw == null || raw === '')
+        return undefined;
+    const t = String(raw).trim();
+    if (ARWEAVE_TX_ID_RE.test(t))
+        return t;
+    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
+    if (m)
+        return m[1];
+    // Values may be full gateway URLs or paths; scan for the embedded tx id.
+    const embedded = t.match(/[a-z0-9_-]{43}/gi);
+    if (embedded) {
+        for (const candidate of embedded) {
+            if (ARWEAVE_TX_ID_RE.test(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+};
+const mergeAddressLists = (a, b) => {
+    const seen = new Set();
+    const out = [];
+    for (const addr of [...(a ?? []), ...(b ?? [])]) {
+        if (!addr || !addr.trim())
+            continue;
+        const k = addr.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(addr);
+    }
+    return out;
+};
+const collectTransactionIdsFromLocalMetadata = async () => {
+    const appDb = await getAppDbReady();
+    if (!appDb) {
+        return [];
+    }
+    const nameOr = or(eq(metadata$1.propertyName, 'storageTransactionId'), eq(metadata$1.propertyName, 'storage_transaction_id'), eq(metadata$1.propertyName, 'transactionId'));
+    const propRows = await appDb
+        .select({ propertyValue: metadata$1.propertyValue })
+        .from(metadata$1)
+        .where(and(nameOr, isNotNull(metadata$1.propertyValue)));
+    const refRows = await appDb
+        .select({ refResolvedValue: metadata$1.refResolvedValue })
+        .from(metadata$1)
+        .where(isNotNull(metadata$1.refResolvedValue));
+    const ids = new Set();
+    for (const row of propRows) {
+        const id = normalizeArweaveTxId(row.propertyValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    for (const row of refRows) {
+        const id = normalizeArweaveTxId(row.refResolvedValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+};
+const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) => {
+    const transactionIds = [];
+    for (const fileMetadata of filesMetadata) {
+        // Validate and parse decodedDataJson
+        if (!fileMetadata.decodedDataJson || fileMetadata.decodedDataJson.trim() === '') {
+            console.warn('[events/files] [download] empty decodedDataJson for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        let json;
+        try {
+            json = JSON.parse(fileMetadata.decodedDataJson);
+        }
+        catch (error) {
+            console.warn('[events/files] [download] failed to parse decodedDataJson for fileMetadata: ', fileMetadata.id, error);
+            continue;
+        }
+        if (!Array.isArray(json) || json.length === 0 || !json[0]?.value?.value) {
+            console.warn('[events/files] [download] invalid decodedDataJson structure for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        const rawTx = json[0].value.value;
+        if (typeof rawTx !== 'string' || rawTx.trim().length === 0) {
+            continue;
+        }
+        const transactionId = normalizeArweaveTxId(rawTx.trim());
+        if (!transactionId) {
+            continue;
+        }
+        if (excludedTransactions.has(transactionId) || excludedTransactions.has(rawTx.trim())) {
+            continue;
+        }
+        transactionIds.push(transactionId);
+    }
+    return transactionIds;
+};
+const downloadTransactionIds = async (rawTransactionIds, options) => {
+    if (!supportsOpfsFileDownloads()) {
+        return false;
+    }
+    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
+    if (transactionIds.length === 0) {
+        return false;
+    }
+    const excludedTransactions = await getExcludedTransactions();
+    const queryClient = BaseQueryClient.getQueryClient();
+    const transactionIdsToDownload = [];
+    await ensureReadGatewaySelected();
+    for (const transactionId of transactionIds) {
+        if (excludedTransactions.has(transactionId)) {
+            continue;
+        }
+        try {
+            // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
+            // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
+            let tags = [];
+            try {
+                tags = await queryClient.fetchQuery({
+                    queryKey: ['getTransactionTags', transactionId],
+                    queryFn: async () => BaseArweaveClient.getTransactionTags(transactionId),
+                });
+            }
+            catch {
+                tags = [];
+            }
+            if (tags && tags.length > 0) {
+                for (const { name, value } of tags) {
+                    if (name !== 'Content-SHA-256')
+                        continue;
+                    const metadataRecord = await getMetadata({
+                        storageTransactionId: transactionId,
+                    });
+                    if (metadataRecord) {
+                        await saveMetadata(metadataRecord, {
+                            contentHash: value,
+                        });
+                    }
+                }
+            }
+            transactionIdsToDownload.push(transactionId);
+        }
+        catch (error) {
+            logger$g(error);
+        }
+    }
+    if (transactionIdsToDownload.length === 0) {
+        return false;
+    }
+    if (transactionIdsToDownload.length === 1) {
+        await BaseFileManager.downloadFileByTransactionId({
+            transactionId: transactionIdsToDownload[0],
+            arweaveHost: BaseArweaveClient.getHost(),
+            excludedTransactions,
+        });
+    }
+    else {
+        await BaseFileManager.downloadAllFiles({
+            transactionIds: transactionIdsToDownload,
+            arweaveHost: BaseArweaveClient.getHost(),
+            excludedTransactions,
+        });
+    }
+    if (options?.resizeAllImages !== false) {
+        await BaseFileManager.resizeAllImages({
+            width: 480,
+            height: 480,
+        });
+    }
+    return true;
+};
+const runBulkDownloadWithDedupe = async (transactionIds) => {
+    if (bulkDownloadInFlight) {
+        return bulkDownloadInFlight;
+    }
+    bulkDownloadInFlight = (async () => {
+        try {
+            await downloadTransactionIds(transactionIds, { resizeAllImages: true });
+        }
+        finally {
+            bulkDownloadInFlight = null;
+        }
+    })();
+    return bulkDownloadInFlight;
+};
+const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    await syncDbFiles();
+    eventEmitter.emit('fs.downloadAll.success', { eventId });
+    eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
+};
+const downloadAllFilesBinaryRequestHandler = async (addressesHintOrPayload) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    const addressesHint = Array.isArray(addressesHintOrPayload)
+        ? addressesHintOrPayload
+        : undefined;
+    let fromDb = [];
+    if (BaseDb.isAppDbReady()) {
+        fromDb = await getAllAddressesFromDb();
+    }
+    if (!BaseDb.isAppDbReady()) {
+        await getAppDbReady();
+        fromDb = await getAllAddressesFromDb();
+    }
+    const addresses = mergeAddressLists(addressesHint, fromDb);
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
+    const queryClient = BaseQueryClient.getQueryClient();
+    const easClient = BaseEasClient.getEasClient();
+    const filesMetadataQueryKey = ['getFilesMetadata', ...addresses];
+    const fetchFilesMetadata = () => easClient.request(GET_FILES_METADATA, {
+        where: {
+            attester: {
+                in: addresses,
+            },
+            schema: {
+                is: {
+                    id: {
+                        equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
+                    },
+                },
+            },
+        },
+    });
+    let { filesMetadata } = await queryClient.fetchQuery({
+        queryKey: filesMetadataQueryKey,
+        queryFn: fetchFilesMetadata,
+        staleTime: GET_FILES_METADATA_STALE_MS,
+    });
+    if ((!Array.isArray(filesMetadata) || filesMetadata.length === 0) && addresses.length > 0) {
+        await queryClient.removeQueries({ queryKey: filesMetadataQueryKey });
+        ({ filesMetadata } = await queryClient.fetchQuery({
+            queryKey: filesMetadataQueryKey,
+            queryFn: fetchFilesMetadata,
+            staleTime: GET_FILES_METADATA_STALE_MS,
+        }));
+    }
+    const filesRoot = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(filesRoot);
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    const excludedTransactions = await getExcludedTransactions();
+    const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
+    const fromLocal = await collectTransactionIdsFromLocalMetadata();
+    const transactionIds = Array.from(new Set([...fromEas, ...fromLocal]));
+    await runBulkDownloadWithDedupe(transactionIds);
+};
+const downloadTransactionIdWithDedupe = async (transactionId) => {
+    if (!supportsOpfsFileDownloads() || !transactionId || transactionId.trim().length === 0) {
+        return false;
+    }
+    const normalizedTxId = normalizeArweaveTxId(transactionId) ?? transactionId.trim();
+    const existing = lazyDownloadInFlightByTransactionId.get(normalizedTxId);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            const ok = await downloadTransactionIds([normalizedTxId], { resizeAllImages: false });
+            return ok;
+        }
+        finally {
+            lazyDownloadInFlightByTransactionId.delete(normalizedTxId);
+        }
+    })();
+    lazyDownloadInFlightByTransactionId.set(normalizedTxId, inFlight);
+    return inFlight;
+};
+const scheduleBulkFilesDownloadFromEasSyncThrottled = throttle((addressesHint) => {
+    void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
+        logger$g('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+    });
+}, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
+const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    scheduleBulkFilesDownloadFromEasSyncThrottled(addressesHint);
+};
+
+var download = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    downloadAllFilesBinaryRequestHandler: downloadAllFilesBinaryRequestHandler,
+    downloadAllFilesRequestHandler: downloadAllFilesRequestHandler,
+    downloadTransactionIdWithDedupe: downloadTransactionIdWithDedupe,
+    scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
+});
+
+/** Published storage seeds use `0x` + 64 hex; `saveHtml` still writes `html/{localId}.html`. */
+const SEED_UID_HEX_RE = /^0x[a-fA-F0-9]{64}$/;
+/** Arweave L1 transaction ids are 43 URL-safe base64 characters. */
+const ARWEAVE_TX_ID_IN_STRING_RE = /[a-z0-9_-]{43}/i;
+function extractArweaveTransactionId(raw) {
+    const t = raw.trim();
+    const embedded = t.match(ARWEAVE_TX_ID_IN_STRING_RE);
+    if (embedded && /^[a-z0-9_-]{43}$/i.test(embedded[0])) {
+        return embedded[0];
+    }
+    return t;
+}
+/**
+ * GET /raw/{txId} on each configured gateway. Avoids arweave.js /tx/.../offset which often 404s on
+ * arweave.net while another gateway (e.g. ar.seedprotocol.io) still serves the data.
+ */
+async function fetchHtmlViaRawAcrossGateways(txId) {
+    const id = extractArweaveTransactionId(txId);
+    if (!id || SEED_UID_HEX_RE.test(id))
+        return undefined;
+    try {
+        const { ensureReadGatewaySelected } = await Promise.resolve().then(function () { return selectReadGateway; });
+        await ensureReadGatewaySelected().catch(() => { });
+    }
+    catch {
+        /* optional */
+    }
+    const { BaseArweaveClient } = await Promise.resolve().then(function () { return BaseArweaveClient$1; });
+    const protocol = BaseArweaveClient.getProtocol();
+    const hosts = mergePrimaryHostWithDefaults(BaseArweaveClient.getHost(), getDefaultArweaveReadGatewayHostsOrdered());
+    for (const host of hosts) {
+        const h = host.trim().replace(/\/$/, '');
+        if (!h)
+            continue;
+        const url = `${protocol}://${h}/raw/${encodeURIComponent(id)}`;
+        try {
+            const res = await fetch(url, { method: 'GET', credentials: 'omit' });
+            if (!res.ok)
+                continue;
+            const text = await res.text();
+            if (typeof text === 'string' && text.length > 0) {
+                return text;
+            }
+        }
+        catch {
+            /* next gateway */
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the Html storage seed's `local_id` used for the `{localId}.html` file name.
+ * `propertyValue` on the parent Html property is either that local id or the seed uid after publish.
+ */
+async function resolveHtmlStorageSeedLocalId(propertyValue) {
+    const pv = String(propertyValue ?? '').trim();
+    if (!pv)
+        return undefined;
+    if (SEED_UID_HEX_RE.test(pv)) {
+        const { getSeedData } = await Promise.resolve().then(function () { return getSeedData$1; });
+        return (await getSeedData({ seedUid: pv }))?.localId ?? undefined;
+    }
+    return pv;
+}
+/**
+ * When the local draft file is gone (new device, OPFS cleared, etc.), load HTML from the
+ * Html storage seed's published Arweave transaction id on that child seed.
+ */
+async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
+    const { getPropertyData } = await Promise.resolve().then(function () { return getPropertyData$1; });
+    const pickTx = async (name) => {
+        const row = await getPropertyData({ propertyName: name, seedLocalId });
+        const v = row?.propertyValue != null ? String(row.propertyValue).trim() : '';
+        return v || undefined;
+    };
+    const txId = (await pickTx('storageTransactionId')) ??
+        (await pickTx('transactionId')) ??
+        (await pickTx('storage_transaction_id'));
+    if (!txId || SEED_UID_HEX_RE.test(txId)) {
+        return { txIdLen: 0, gatewayStringLen: 0 };
+    }
+    const rawHtml = await fetchHtmlViaRawAcrossGateways(txId);
+    if (rawHtml && rawHtml.length > 0) {
+        return { body: rawHtml, txIdLen: txId.length, gatewayStringLen: rawHtml.length };
+    }
+    try {
+        const { BaseArweaveClient } = await Promise.resolve().then(function () { return BaseArweaveClient$1; });
+        const data = await BaseArweaveClient.getTransactionData(extractArweaveTransactionId(txId), {
+            string: true,
+        });
+        if (typeof data === 'string' && data.length > 0) {
+            return { body: data, txIdLen: txId.length, gatewayStringLen: data.length };
+        }
+    }
+    catch {
+        /* offline / bad tx id */
+    }
+    try {
+        const { downloadTransactionIdWithDedupe } = await Promise.resolve().then(function () { return download; });
+        await downloadTransactionIdWithDedupe(txId);
+        const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
+        if (await BaseFileManager.pathExists(retryFp)) {
+            const s = await BaseFileManager.readFileAsString(retryFp);
+            return { body: s, txIdLen: txId.length, gatewayStringLen: 0 };
+        }
+        const dirPath = BaseFileManager.getFilesPath('html');
+        if (await BaseFileManager.pathExists(dirPath)) {
+            const fs = await BaseFileManager.getFs();
+            const pathMod = BaseFileManager.getPathModule();
+            const files = await fs.promises.readdir(dirPath);
+            const needle = txId.replace(/\.[^/.]+$/, '');
+            const match = files.find((f) => f.includes(seedLocalId) || f.includes(needle) || (needle.length >= 20 && f.includes(needle.slice(0, 20))));
+            if (match) {
+                const s = await BaseFileManager.readFileAsString(pathMod.join(dirPath, match));
+                return { body: s, txIdLen: txId.length, gatewayStringLen: 0 };
+            }
+        }
+    }
+    catch {
+        /* OPFS unsupported or download failed */
+    }
+    return { txIdLen: txId.length, gatewayStringLen: 0 };
+}
+/** Read saved HTML body for a parent Html property whose `propertyValue` points at the Html storage seed. */
+async function readHtmlBodyForStorageSeedPropertyValue(propertyValue) {
+    const pv = String(propertyValue ?? '').trim();
+    if (!pv)
+        return undefined;
+    const localId = await resolveHtmlStorageSeedLocalId(propertyValue);
+    const fp = localId ? BaseFileManager.getFilesPath('html', `${localId}.html`) : '';
+    let fileExists = fp ? await BaseFileManager.pathExists(fp) : false;
+    // OPFS: file can appear shortly after create/download; avoid false "missing" before hitting Arweave.
+    if (!fileExists && fp) {
+        await BaseFileManager.waitForFileWithContent(fp, 100, 5000).catch(() => { });
+        fileExists = await BaseFileManager.pathExists(fp);
+    }
+    let body = fileExists && fp ? await BaseFileManager.readFileAsString(fp) : undefined;
+    if (!body && localId) {
+        const ar = await readHtmlBodyFromChildStorageArweave(localId);
+        body = ar.body;
+    }
+    return body;
+}
+
+// Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
+// import { ModelPropertyDataTypes } from '@/schema'
+const logger$f = debug('seedSdk:property:actors:hydrateFromDb');
+const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
+    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
+    if (!propertyNameRaw) {
+        throw new Error('propertyName is required');
+    }
+    let propertyName = propertyNameRaw;
+    // Note: isRelation, isImage, isFile checks moved inside async function
+    // to use dynamically imported ModelPropertyDataTypes
+    const _hydrateFromDb = async () => {
+        // Use dynamic import to break circular dependency
+        const schemaMod = await import('./index-DB3nZ0lK.js');
+        const { ModelPropertyDataTypes } = schemaMod;
+        const appDb = BaseDb.getAppDb();
+        const whereClauses = [];
+        // Re-check types with dynamically imported ModelPropertyDataTypes
+        // Use normalizeDataType for case-insensitive comparison (schema may use "image" vs "Image")
+        const normalizedDataType = normalizeDataType(propertyRecordSchema?.dataType);
+        const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
+        propertyRecordSchema &&
+            propertyRecordSchema.ref &&
+            normalizedDataType === ModelPropertyDataTypes.Relation;
+        const isImageDynamic = propertyRecordSchema &&
+            (normalizedDataType === ModelPropertyDataTypes.Image ||
+                normalizedRefValueType === ModelPropertyDataTypes.Image);
+        const isFileDynamic = propertyRecordSchema &&
+            normalizedDataType === ModelPropertyDataTypes.File;
+        const isHtmlDynamic = propertyRecordSchema &&
+            normalizedDataType === ModelPropertyDataTypes.Html;
+        // Html/Image/File/Relation store metadata with Id suffix (e.g. htmlId); query both variants
+        const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
+        whereClauses.push(propertyNames.length > 1
+            ? or(...propertyNames.map((n) => eq(metadata$1.propertyName, n)))
+            : eq(metadata$1.propertyName, propertyNames[0]));
+        // Draft rows often have only seed_local_id populated; on-chain rows may have uid.
+        // Requiring both with AND misses valid metadata when only one column is set.
+        if (seedUid && seedLocalId) {
+            whereClauses.push(or(eq(metadata$1.seedLocalId, seedLocalId), eq(metadata$1.seedUid, seedUid)));
+        }
+        else if (seedUid) {
+            whereClauses.push(eq(metadata$1.seedUid, seedUid));
+        }
+        else if (seedLocalId) {
+            whereClauses.push(eq(metadata$1.seedLocalId, seedLocalId));
+        }
+        const rows = await appDb
+            .select()
+            .from(metadata$1)
+            .where(and(...whereClauses))
+            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'));
+        if (!rows || !rows.length) {
+            return;
+        }
+        const firstRow = rows[0];
+        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, } = firstRow;
+        let { refResolvedDisplayValue, refResolvedValue, localStorageDir } = firstRow;
+        let propertyValueProcessed = propertyValueFromDb;
+        let renderValue = refResolvedDisplayValue ?? undefined;
+        // Image: always resolve display value from file (blob URLs in DB are invalid after reload)
+        if (isImageDynamic) {
+            let dir = localStorageDir;
+            if (!dir && isImageDynamic) {
+                dir = 'images';
+            }
+            dir = dir.replace(/^\//, '');
+            if (propertyValueFromDb &&
+                propertyValueFromDb.length === 66) {
+                // Here the storageTransactionId is stored on a different record and
+                // we want to add it as the refResolvedValue
+                const storageTransactionQuery = await appDb
+                    .select({
+                    propertyValue: metadata$1.propertyValue,
+                })
+                    .from(metadata$1)
+                    .where(and(eq(metadata$1.seedUid, propertyValueFromDb), or(eq(metadata$1.propertyName, 'storageTransactionId'), eq(metadata$1.propertyName, 'transactionId'))));
+                if (storageTransactionQuery && storageTransactionQuery.length > 0) {
+                    const row = storageTransactionQuery[0];
+                    refResolvedValue = row.propertyValue;
+                    await updateMetadata({
+                        localId,
+                        refResolvedValue,
+                        localStorageDir: '/images',
+                    });
+                }
+            }
+            const resolveMatchingFilePath = async (dir, needle) => {
+                const dirPath = BaseFileManager.getFilesPath(dir);
+                const dirExists = await BaseFileManager.pathExists(dirPath);
+                if (!dirExists)
+                    return undefined;
+                const fs = await BaseFileManager.getFs();
+                const path = BaseFileManager.getPathModule();
+                const files = await fs.promises.readdir(dirPath);
+                const matchingFiles = files.filter((file) => {
+                    return path.basename(file).includes(needle);
+                });
+                if (!matchingFiles?.length)
+                    return undefined;
+                return BaseFileManager.getFilesPath(dir, matchingFiles[0]);
+            };
+            if (refResolvedValue) {
+                try {
+                    let filePath = await resolveMatchingFilePath(dir, refResolvedValue);
+                    if (!filePath) {
+                        await downloadTransactionIdWithDedupe(refResolvedValue);
+                        filePath = await resolveMatchingFilePath(dir, refResolvedValue);
+                    }
+                    localStorageDir = `/${dir}`;
+                    if (filePath) {
+                        const file = await BaseFileManager.readFile(filePath);
+                        refResolvedDisplayValue = URL.createObjectURL(file);
+                        renderValue = refResolvedDisplayValue;
+                        // Do not persist blob URL - it is session-scoped
+                    }
+                }
+                catch (e) {
+                    logger$f('[hydrateFromDb] Image file resolution error', e);
+                }
+            }
+        }
+        if (isFileDynamic && refResolvedValue) {
+            try {
+                const dir = (localStorageDir ?? '/files').replace(/^\//, '');
+                const resolveMatchingFilePath = async (needle) => {
+                    const dirPath = BaseFileManager.getFilesPath(dir);
+                    const dirExists = await BaseFileManager.pathExists(dirPath);
+                    if (!dirExists)
+                        return undefined;
+                    const fs = await BaseFileManager.getFs();
+                    const path = BaseFileManager.getPathModule();
+                    const files = await fs.promises.readdir(dirPath);
+                    const matchingFiles = files.filter((file) => path.basename(file).includes(needle));
+                    if (!matchingFiles?.length)
+                        return undefined;
+                    return BaseFileManager.getFilesPath(dir, matchingFiles[0]);
+                };
+                let filePath = await resolveMatchingFilePath(refResolvedValue);
+                if (!filePath) {
+                    await downloadTransactionIdWithDedupe(refResolvedValue);
+                    filePath = await resolveMatchingFilePath(refResolvedValue);
+                }
+                if (filePath) {
+                    localStorageDir = `/${dir}`;
+                    renderValue = await BaseFileManager.readFileAsString(filePath);
+                }
+            }
+            catch (e) {
+                logger$f('[hydrateFromDb] File resolution error', e);
+            }
+        }
+        if (propertyRecordSchema &&
+            normalizedDataType === ModelPropertyDataTypes.List &&
+            typeof propertyValueFromDb === 'string') {
+            propertyValueProcessed = parseListPropertyValueFromStorage(propertyValueFromDb);
+        }
+        sendBack({
+            type: 'updateContext',
+            localId,
+            uid,
+            propertyValue: propertyValueProcessed,
+            seedLocalId: seedLocalIdFromDb,
+            seedUid: seedUidFromDb,
+            versionLocalId: versionLocalIdFromDb,
+            versionUid: versionUidFromDb,
+            schemaUid: schemaUidFromDb,
+            refValueType,
+            localStorageDir,
+            refResolvedValue,
+            refResolvedDisplayValue,
+            renderValue,
+            populatedFromDb: true,
+        });
+        if (propertyRecordSchema &&
+            propertyRecordSchema.storageType &&
+            propertyRecordSchema.storageType === 'ItemStorage') {
+            const itemMod = await Promise.resolve().then(function () { return Item$1; });
+            const { Item } = itemMod;
+            const item = await Item.find({
+                seedLocalId: seedLocalId ?? undefined,
+                modelName,
+            });
+            if (item) {
+                const dir = localStorageDir?.replace(/^\//, '') || 'files';
+                const filePath = BaseFileManager.getFilesPath(dir, refResolvedValue);
+                const exists = await BaseFileManager.pathExists(filePath);
+                if (!exists) {
                     return;
                 }
                 const renderValue = await BaseFileManager.readFileAsString(filePath);
@@ -8165,15 +9144,34 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 return;
             }
         }
-        // Html: read file content for renderValue (blob URLs from DB are invalid after reload)
-        // Fallback: when localStorageDir is null (e.g. EAS sync, legacy records) use '/html'
-        const htmlLocalStorageDir = isHtmlDynamic && refResolvedValue && !localStorageDir ? '/html' : localStorageDir;
-        if (isHtmlDynamic && refResolvedValue && htmlLocalStorageDir) {
-            const dir = htmlLocalStorageDir.replace(/^\//, '');
-            const filePath = BaseFileManager.getFilesPath(dir, refResolvedValue);
-            const exists = await BaseFileManager.pathExists(filePath);
-            if (exists) {
-                const htmlContent = await BaseFileManager.readFileAsString(filePath);
+        // Html: read file content for renderValue (blob URLs from DB are invalid after reload).
+        // When propertyValue is the Html storage seed uid, resolve localId and read `html/{localId}.html`.
+        if (isHtmlDynamic) {
+            const htmlLocalStorageDir = refResolvedValue && !localStorageDir ? '/html' : localStorageDir ?? '/html';
+            let htmlContent;
+            let outRef = refResolvedValue;
+            let outDir = htmlLocalStorageDir;
+            if (refResolvedValue && htmlLocalStorageDir) {
+                const dir = htmlLocalStorageDir.replace(/^\//, '');
+                const filePath = BaseFileManager.getFilesPath(dir, refResolvedValue);
+                let exists = await BaseFileManager.pathExists(filePath);
+                if (!exists) {
+                    await BaseFileManager.waitForFileWithContent(filePath, 100, 5000).catch(() => { });
+                    exists = await BaseFileManager.pathExists(filePath);
+                }
+                if (exists) {
+                    htmlContent = await BaseFileManager.readFileAsString(filePath);
+                }
+            }
+            if (!htmlContent && propertyValueFromDb) {
+                htmlContent = await readHtmlBodyForStorageSeedPropertyValue(propertyValueFromDb);
+                const lid = await resolveHtmlStorageSeedLocalId(String(propertyValueFromDb));
+                if (lid) {
+                    outRef = `${lid}.html`;
+                    outDir = '/html';
+                }
+            }
+            if (htmlContent) {
                 sendBack({
                     type: 'updateContext',
                     localId,
@@ -8185,8 +9183,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     versionUid: versionUidFromDb,
                     schemaUid: schemaUidFromDb,
                     refValueType,
-                    localStorageDir: htmlLocalStorageDir,
-                    refResolvedValue,
+                    localStorageDir: outDir,
+                    refResolvedValue: outRef ?? refResolvedValue,
                     refResolvedDisplayValue,
                     renderValue: htmlContent,
                     populatedFromDb: true,
@@ -8200,11 +9198,11 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$f = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$e = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$f(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$e(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -8250,15 +9248,15 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         const schemas = modelPropertiesToObject(model$1.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$f(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$e(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$f(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$e(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$f(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$e(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -8324,7 +9322,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-C63Ddzap.js');
+                            const { getPropertySchema } = await import('./property-DViA9nga.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8362,7 +9360,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (error) {
-                logger$f(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$e(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
@@ -8380,22 +9378,27 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                     const schemas = modelPropertiesToObject(model$1.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$f(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$e(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$f(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$e(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
             }
         }
         // For Html: read file content for renderValue (propertyValue is seed ID; blob URLs in DB are invalid after reload)
         let renderValue = metadataRecord.propertyValue || undefined;
         const refSeedType = metadataRecord.refSeedType;
-        const isHtml = refSeedType === 'html' || propertyRecordSchema?.dataType === 'Html';
-        // Fallback: derive refResolvedValue/localStorageDir from propertyValue when missing (e.g. EAS sync, legacy data)
+        const normalizedHtmlDt = normalizeDataType(propertyRecordSchema?.dataType);
+        const isHtml = refSeedType === 'html' || normalizedHtmlDt === ModelPropertyDataTypes.Html;
+        // Fallback: derive refResolvedValue/localStorageDir from propertyValue when missing (e.g. EAS sync, legacy data).
+        // After publish, propertyValue may be the Html storage seed uid while files stay named `{localId}.html`.
         if (isHtml && !metadataRecord.refResolvedValue && metadataRecord.propertyValue) {
-            metadataRecord.refResolvedValue = `${metadataRecord.propertyValue}.html`;
-            metadataRecord.localStorageDir = '/html';
+            const lid = await resolveHtmlStorageSeedLocalId(metadataRecord.propertyValue);
+            if (lid) {
+                metadataRecord.refResolvedValue = `${lid}.html`;
+                metadataRecord.localStorageDir = '/html';
+            }
         }
         // Fallback: when Html has refResolvedValue but localStorageDir is null (e.g. EAS sync, legacy records)
         if (isHtml && metadataRecord.refResolvedValue && !metadataRecord.localStorageDir) {
@@ -8405,13 +9408,34 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             try {
                 const dir = metadataRecord.localStorageDir.replace(/^\//, '');
                 const filePath = BaseFileManager.getFilesPath(dir, metadataRecord.refResolvedValue);
-                const exists = await BaseFileManager.pathExists(filePath);
+                let exists = await BaseFileManager.pathExists(filePath);
+                if (!exists) {
+                    await BaseFileManager.waitForFileWithContent(filePath, 100, 5000).catch(() => { });
+                    exists = await BaseFileManager.pathExists(filePath);
+                }
                 if (exists) {
                     renderValue = await BaseFileManager.readFileAsString(filePath);
                 }
+                else {
+                    const viaSeedPointer = await readHtmlBodyForStorageSeedPropertyValue(metadataRecord.propertyValue);
+                    if (viaSeedPointer) {
+                        renderValue = viaSeedPointer;
+                    }
+                }
             }
             catch (e) {
-                logger$f(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$e(`Failed to read Html file for ${propertyName}: ${e}`);
+            }
+        }
+        // Covers missing ref row, wrong ref, or DB dataType casing "html" (handled by isHtml above).
+        if (isHtml && metadataRecord.propertyValue) {
+            const pv = String(metadataRecord.propertyValue).trim();
+            const rv = typeof renderValue === 'string' ? renderValue.trim() : '';
+            if (!rv || rv === pv) {
+                const recovered = await readHtmlBodyForStorageSeedPropertyValue(metadataRecord.propertyValue);
+                if (recovered) {
+                    renderValue = recovered;
+                }
             }
         }
         // Image: always resolve display value from file (blob URLs in DB are invalid after reload)
@@ -8421,28 +9445,83 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         const isImage = refSeedType === 'image' ||
             normalizedDataType === 'Image' ||
             normalizedRefValueType === 'Image';
+        const resolveMatchingFilePath = async (dir, needle) => {
+            const dirPath = BaseFileManager.getFilesPath(dir);
+            const dirExists = await BaseFileManager.pathExists(dirPath);
+            if (!dirExists)
+                return undefined;
+            const fs = await BaseFileManager.getFs();
+            const path = BaseFileManager.getPathModule();
+            const files = await fs.promises.readdir(dirPath);
+            const matchingFiles = files.filter((file) => path.basename(file).includes(needle));
+            if (!matchingFiles?.length)
+                return undefined;
+            return BaseFileManager.getFilesPath(dir, matchingFiles[0]);
+        };
+        // EAS-synced rows: parent metadata stores the image seed uid in property_value; filename/Arweave id is on the image seed's metadata.
+        // hydrateFromDb already repairs this; doing it here avoids a multi-second gap where UI shows a non-blob value until rehydrate runs.
+        if (isImage &&
+            !metadataRecord.refResolvedValue &&
+            typeof metadataRecord.propertyValue === 'string' &&
+            metadataRecord.propertyValue.length === 66) {
+            const storageTxRows = await db
+                .select({ propertyValue: metadata$1.propertyValue })
+                .from(metadata$1)
+                .where(and(eq(metadata$1.seedUid, metadataRecord.propertyValue), or(eq(metadata$1.propertyName, 'storageTransactionId'), eq(metadata$1.propertyName, 'transactionId'))))
+                .limit(1);
+            const derivedTxId = storageTxRows[0]?.propertyValue;
+            if (derivedTxId) {
+                metadataRecord.refResolvedValue = derivedTxId;
+                metadataRecord.localStorageDir = metadataRecord.localStorageDir ?? '/images';
+                if (metadataRecord.localId) {
+                    try {
+                        await updateMetadata({
+                            localId: metadataRecord.localId,
+                            refResolvedValue: derivedTxId,
+                            localStorageDir: '/images',
+                        });
+                    }
+                    catch (e) {
+                        logger$e(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
+                    }
+                }
+            }
+        }
         if (isImage && metadataRecord.refResolvedValue) {
             try {
                 const dir = (metadataRecord.localStorageDir ?? '/images').replace(/^\//, '');
-                const dirPath = BaseFileManager.getFilesPath(dir);
-                const dirExists = await BaseFileManager.pathExists(dirPath);
-                if (dirExists) {
-                    const fs = await BaseFileManager.getFs();
-                    const path = BaseFileManager.getPathModule();
-                    const files = await fs.promises.readdir(dirPath);
-                    const matchingFiles = files.filter((file) => path.basename(file).includes(metadataRecord.refResolvedValue));
-                    if (matchingFiles?.length > 0) {
-                        const filename = matchingFiles[0];
-                        const filePath = BaseFileManager.getFilesPath(dir, filename);
-                        const file = await BaseFileManager.readFile(filePath);
-                        const freshBlobUrl = URL.createObjectURL(file);
-                        renderValue = freshBlobUrl;
-                        refResolvedDisplayValue = freshBlobUrl;
-                    }
+                let filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
+                if (!filePath) {
+                    await downloadTransactionIdWithDedupe(metadataRecord.refResolvedValue);
+                    filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
+                }
+                if (filePath) {
+                    const file = await BaseFileManager.readFile(filePath);
+                    const freshBlobUrl = URL.createObjectURL(file);
+                    renderValue = freshBlobUrl;
+                    refResolvedDisplayValue = freshBlobUrl;
+                }
+            }
+            catch (e) {
+                logger$e(`Failed to resolve Image file for ${propertyName}: ${e}`);
+            }
+        }
+        const isFile = refSeedType === 'file' ||
+            normalizedDataType === 'File';
+        if (isFile && metadataRecord.refResolvedValue) {
+            try {
+                const dir = (metadataRecord.localStorageDir ?? '/files').replace(/^\//, '');
+                let filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
+                if (!filePath) {
+                    await downloadTransactionIdWithDedupe(metadataRecord.refResolvedValue);
+                    filePath = await resolveMatchingFilePath(dir, metadataRecord.refResolvedValue);
+                }
+                if (filePath) {
+                    renderValue = await BaseFileManager.readFileAsString(filePath);
                 }
             }
             catch (e) {
-                logger$f(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$e(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -8474,7 +9553,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$f(`Error in loadOrCreateProperty: ${error}`);
+        logger$e(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -8504,10 +9583,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$e = debug('seedSdk:write:updateItemPropertyValue');
+const logger$d = debug('seedSdk:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, dataType, refValueType, }) => {
     if (!localIdParam && !seedLocalId) {
-        logger$e(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$d(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -8535,7 +9614,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
                 .select()
                 .from(metadata$1)
                 .where(and(propertyNameWhere, eq(metadata$1.seedLocalId, seedLocalId)))
-                .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC')));
+                .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC, local_id DESC')));
         }
     }
     else if (localIdParam) {
@@ -8555,7 +9634,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             .select()
             .from(metadata$1)
             .where(and(propertyNameWhere, eq(metadata$1.seedLocalId, seedLocalId)))
-            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC')));
+            .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC, local_id DESC')));
     }
     // const mostRecentRecordStatement = `SELECT local_id,
     //                                           uid,
@@ -8571,7 +9650,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
     //                                    FROM metadata
     //                                    WHERE property_name = '${propertyName}'
     //                                      AND seed_local_id = '${seedLocalId}'
-    //                                    ORDER BY COALESCE(attestation_created_at, created_at) DESC;`
+    //                                    ORDER BY COALESCE(attestation_created_at, created_at) DESC, local_id DESC;`
     //
     // const { rows } = await runQueryForStatement(mostRecentRecordStatement)
     if (rows && rows.length > 0) {
@@ -8580,7 +9659,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$e(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$d(`[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
@@ -8708,9 +9787,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cqf_DxkJ.js');
+        const schemaMod = await import('./index-DB3nZ0lK.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-Cb-b4kpD.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DXYRdSYa.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8908,7 +9987,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-Cb-b4kpD.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-DXYRdSYa.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, propertyRecordSchema.dataType, propertyRecordSchema.validation, propertyRecordSchema.refValueType);
         if (!validationResult.isValid && validationResult.errors.length > 0) {
@@ -8986,8 +10065,6 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
     return inserted[0];
 };
 
-const eventEmitter = new EventEmitter();
-
 const readFileAsArrayBuffer$1 = async (file) => {
     return new Promise((resolve) => {
         const reader = new FileReader();
@@ -9134,6 +10211,12 @@ const saveImage = fromCallback(({ sendBack, input: { context, event } }) => {
         }
         const refResolvedDisplayValue = await BaseFileManager.getContentUrlFromPath(filePath);
         let newLocalId;
+        const resolvedPropertySchemaUid = schemaUid && schemaUid !== imageSchemaUid
+            ? schemaUid
+            : (await getEasSchemaForItemProperty({
+                propertyName,
+                easDataType: 'bytes32',
+            }))?.id;
         if (!localId) {
             const result = await createMetadata({
                 propertyName,
@@ -9143,7 +10226,7 @@ const saveImage = fromCallback(({ sendBack, input: { context, event } }) => {
                 versionLocalId,
                 versionUid,
                 modelName,
-                schemaUid: imageSchemaUid,
+                schemaUid: resolvedPropertySchemaUid,
                 refSeedType: 'image',
                 refModelUid: imageSchemaUid,
                 refResolvedValue: fileName,
@@ -9162,7 +10245,7 @@ const saveImage = fromCallback(({ sendBack, input: { context, event } }) => {
                 seedLocalId,
                 versionLocalId,
                 modelName,
-                schemaUid,
+                schemaUid: resolvedPropertySchemaUid,
                 refSeedType: 'image',
                 refResolvedValue: fileName,
                 localStorageDir: '/images',
@@ -9495,7 +10578,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-Cqf_DxkJ.js');
+        const schemaMod = await import('./index-DB3nZ0lK.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9704,6 +10787,10 @@ const propertyMachine = setup({
         context: {},
         input: {},
     },
+    guards: {
+        // stateIn return type does not satisfy setup() inference; runtime guard is correct for root state `idle`.
+        propertyMachineIsIdle: stateIn('idle'),
+    },
     // actions: {
     //   updateContext: updateMachineContext,
     // },
@@ -9726,7 +10813,11 @@ const propertyMachine = setup({
     initial: 'waitingForDb',
     context: ({ input }) => input,
     on: {
-        // reload: '.hydratingFromDb',
+        /** Re-run DB hydration (e.g. after EAS sync wrote new metadata for this version). */
+        rehydrateFromDb: {
+            guard: 'propertyMachineIsIdle',
+            target: '.hydratingFromDb',
+        },
         save: {
             actions: assign({
                 isSaving: true,
@@ -10325,6 +11416,8 @@ function createReactiveProxy(config) {
     return proxy;
 }
 
+/** Parent Html property `propertyValue` after publish (66-char seed uid). */
+const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
 // Start loading Model at module load time (non-blocking)
 Promise.resolve().then(function () { return Model$1; }).then(module => {
     module.Model;
@@ -10424,7 +11517,7 @@ const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, mod
 };
 /** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
 const modelTypeToModelName = (modelType) => modelType ? upperFirst(camelCase(modelType)) : '';
-const logger$d = debug('seedSdk:property:class');
+const logger$c = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES$2 = [
@@ -10506,7 +11599,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$d('List property value is not JSON', e);
+                        logger$c('List property value is not JSON', e);
                     }
                 }
             }
@@ -10529,7 +11622,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-Cqf_DxkJ.js');
+            const schemaMod = await import('./index-DB3nZ0lK.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -10552,7 +11645,8 @@ class ItemProperty {
                 propertyRecordSchema.storageType === 'ItemStorage' &&
                 context.refResolvedValue &&
                 context.localStorageDir;
-            const isHtml = (context.refSeedType === 'html' || (propertyRecordSchema?.dataType === ModelPropertyDataTypes.Html)) &&
+            const normalizedSchemaDt = normalizeDataType(propertyRecordSchema?.dataType);
+            const isHtml = (context.refSeedType === 'html' || normalizedSchemaDt === ModelPropertyDataTypes.Html) &&
                 context.refResolvedValue;
             // Fix: When File/Image property has a File object before save completes, set refResolvedValue and renderValue
             // so the UI can display the filename and preview immediately (these update again when save completes)
@@ -10588,7 +11682,11 @@ class ItemProperty {
                 const dir = context.localStorageDir?.replace(/^\//, '') || (isHtml ? 'html' : 'images');
                 const filePath = BaseFileManager.getFilesPath(dir, context.refResolvedValue);
                 try {
-                    const exists = await BaseFileManager.pathExists(filePath);
+                    let exists = await BaseFileManager.pathExists(filePath);
+                    if (!exists && isHtml) {
+                        await BaseFileManager.waitForFileWithContent(filePath, 100, 5000).catch(() => { });
+                        exists = await BaseFileManager.pathExists(filePath);
+                    }
                     if (exists && (isItemStorage || isHtml)) {
                         renderValue = await BaseFileManager.readFileAsString(filePath);
                     }
@@ -10608,8 +11706,8 @@ class ItemProperty {
                         if (isFile && isFileValue) {
                             renderValue = pv.name;
                         }
-                        else if (isImage) {
-                            // FS race / path not visible yet: do not clobber a hydrated blob URL with "No file found"
+                        else if (isImage || isHtml) {
+                            // FS race, OPFS cleared, or HTML served from Arweave: do not clobber hydrated/rehydrated value
                             renderValue = undefined;
                         }
                         else {
@@ -10618,13 +11716,21 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$d(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
-                    renderValue = 'No file found';
+                    logger$c(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    renderValue = isHtml ? undefined : 'No file found';
                 }
             }
             if (!renderValue) {
                 renderValue = context.renderValue || context.propertyValue;
             }
+            const pvStr = typeof context.propertyValue === 'string' ? context.propertyValue.trim() : '';
+            if (normalizedSchemaDt === ModelPropertyDataTypes.Html &&
+                HTML_PROP_SEED_UID_RE.test(pvStr) &&
+                renderValue === pvStr &&
+                typeof context.renderValue === 'string' &&
+                context.renderValue.length > pvStr.length) {
+                renderValue = context.renderValue;
+            }
             let transformedPropertyName = propertyName;
             const skipTransform = INTERNAL_PROPERTY_NAMES.includes(propertyName) || !!this._alias;
             if (!skipTransform && transformedPropertyName.endsWith('Id')) {
@@ -10687,7 +11793,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_6 = await import('./index-DdzhrbkF.js');
+                const _mod_6 = await import('./index-Bp0ChnQr.js');
                 const _ns_6 = _mod_6.s;
                 const seedSchemaMod = _ns_6;
                 const { metadata } = seedSchemaMod;
@@ -11039,6 +12145,35 @@ class ItemProperty {
                     instance._service.send({ type: 'updateContext', ...updates });
                 }
             }
+            // After wipe/reconnect, cached actors can stay idle with stale renderValue while DB + Arweave
+            // paths would hydrate. Re-run DB hydration without clobbering propertyValue.
+            const svc = instance._service;
+            const snap = svc.getSnapshot();
+            if (snap.status === 'active' && snap.value === 'idle') {
+                const schema = props.propertyRecordSchema ?? ctx.propertyRecordSchema;
+                const dt = normalizeDataType(schema?.dataType);
+                const isHtmlProp = props.refSeedType === 'html' ||
+                    ctx.refSeedType === 'html' ||
+                    dt === ModelPropertyDataTypes.Html;
+                const isListProp = dt === ModelPropertyDataTypes.List;
+                const isRelationProp = dt === ModelPropertyDataTypes.Relation;
+                const pv = ctx.propertyValue;
+                const pvStr = typeof pv === 'string' ? pv.trim() : '';
+                const renderVal = ctx.renderValue;
+                const renderMissing = renderVal == null || (typeof renderVal === 'string' && renderVal.length === 0);
+                const htmlStuckOnUid = isHtmlProp &&
+                    HTML_PROP_SEED_UID_RE.test(pvStr) &&
+                    (renderMissing || renderVal === pv);
+                const pvPresent = pv != null &&
+                    (Array.isArray(pv) ? pv.length > 0 : String(pv).trim().length > 0);
+                const listOrRelationNeedsResolve = (isListProp || isRelationProp) && renderMissing && pvPresent;
+                const versionChanged = props.versionLocalId != null &&
+                    ctx.versionLocalId != null &&
+                    props.versionLocalId !== ctx.versionLocalId;
+                if (htmlStuckOnUid || listOrRelationNeedsResolve || versionChanged) {
+                    svc.send({ type: 'rehydrateFromDb' });
+                }
+            }
             // On cache hit, do not sync propertyValue: refetches can race with in-memory updates (e.g. save()).
             if (!waitForReady)
                 return instance;
@@ -11388,7 +12523,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await import('./ownership-BK6suksO.js');
+        const { assertItemOwned } = await import('./ownership-D-KsIkxM.js');
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -11481,7 +12616,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_7 = await import('./index-DdzhrbkF.js');
+                    const _mod_7 = await import('./index-Bp0ChnQr.js');
                     const _ns_7 = _mod_7.s;
                     const seedSchemaMod = _ns_7;
                     const { metadata } = seedSchemaMod;
@@ -11729,7 +12864,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await import('./ownership-BK6suksO.js');
+            const { assertItemOwned } = await import('./ownership-D-KsIkxM.js');
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -11753,7 +12888,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await import('./ownership-BK6suksO.js');
+            const { assertItemOwned } = await import('./ownership-D-KsIkxM.js');
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11789,12 +12924,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-DS2dQ4Ho.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-CH72lAID.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await import('./getPublishPayload-DpYwi-rd.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-DEdHgrgC.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -11911,6 +13046,8 @@ class Item {
             'schemaUid',
             'latestVersionLocalId',
             'latestVersionUid',
+            'publishedVersionUid',
+            'publishedVersionLocalId',
         ];
         const keysFromInitial = Object.keys(initialValues).filter((key) => !metadataKeys.includes(key));
         const schemaNameForModel = initialValues.schemaName;
@@ -11954,6 +13091,128 @@ class Item {
             });
         }
     }
+    /** Prefer local id so list rows (local + uid) resolve the same cache entry as early draft loads. */
+    static findItemInstanceCacheEntryByProps(props) {
+        const l = props.seedLocalId;
+        const u = props.seedUid;
+        if (typeof l === 'string' && l.length > 0) {
+            const e = this.instanceCache.get(l);
+            if (e)
+                return e;
+        }
+        if (typeof u === 'string' && u.length > 0) {
+            const e = this.instanceCache.get(u);
+            if (e)
+                return e;
+        }
+        return undefined;
+    }
+    static findItemInstanceCacheEntryById(id) {
+        const direct = this.instanceCache.get(id);
+        if (direct)
+            return direct;
+        for (const [, entry] of this.instanceCache) {
+            const ctx = entry.instance._getSnapshotContext();
+            if (ctx.seedLocalId === id || ctx.seedUid === id)
+                return entry;
+        }
+        return undefined;
+    }
+    static collectInstanceCacheKeysForInstance(instance) {
+        const keys = [];
+        for (const [k, v] of this.instanceCache) {
+            if (v.instance === instance)
+                keys.push(k);
+        }
+        return keys;
+    }
+    static registerItemInInstanceCache(instance) {
+        const ctx = instance._getSnapshotContext();
+        const lid = typeof ctx.seedLocalId === 'string' && ctx.seedLocalId.length > 0
+            ? ctx.seedLocalId
+            : undefined;
+        const uid = typeof ctx.seedUid === 'string' && ctx.seedUid.length > 0 ? ctx.seedUid : undefined;
+        const entry = { instance, refCount: 1 };
+        if (lid)
+            this.instanceCache.set(lid, entry);
+        if (uid && uid !== lid)
+            this.instanceCache.set(uid, entry);
+        if (!lid && !uid) {
+            throw new Error('Item.registerItemInInstanceCache: missing seedLocalId and seedUid');
+        }
+    }
+    static releaseItemInstanceCacheHold(instance) {
+        const keys = this.collectInstanceCacheKeysForInstance(instance);
+        if (keys.length === 0)
+            return;
+        const entry = this.instanceCache.get(keys[0]);
+        entry.refCount -= 1;
+        if (entry.refCount <= 0) {
+            for (const k of keys) {
+                this.instanceCache.delete(k);
+            }
+        }
+    }
+    /**
+     * Item machine can reach `idle` before `propertyInstances` is merged (race) or while
+     * child ItemProperty actors are still hydrating. useItems / Item.all must not return that shell.
+     */
+    static async waitForItemInstanceReadyForRead(item, readyTimeout) {
+        await waitForEntityIdle(item, { timeout: readyTimeout });
+        const svc = item.getService();
+        try {
+            await waitFor(svc, (snap) => {
+                if ('value' in snap && snap.value === 'error') {
+                    throw new Error('Entity failed to load');
+                }
+                if (!('value' in snap) || snap.value !== 'idle') {
+                    return false;
+                }
+                const ctx = snap.context || {};
+                const versionsCount = ctx.versionsCount ?? 0;
+                const hasHeadVersion = !!ctx.latestVersionLocalId;
+                if (versionsCount === 0 && !hasHeadVersion) {
+                    return true;
+                }
+                return (ctx.propertyInstances?.size ?? 0) > 0;
+            }, { timeout: readyTimeout });
+        }
+        catch (e) {
+            if (e?.message === 'Entity failed to load') {
+                throw e;
+            }
+            const msg = typeof e?.message === 'string' ? e.message : '';
+            const isWaitForTimeout = msg.includes('Timeout') || msg.toLowerCase().includes('timed out');
+            if (!isWaitForTimeout) {
+                throw e;
+            }
+        }
+        const snap = svc.getSnapshot();
+        const pis = snap.context?.propertyInstances;
+        if (!pis || pis.size === 0) {
+            return;
+        }
+        await Promise.all([...pis.values()].map((prop) => waitForEntityIdle(prop, {
+            timeout: readyTimeout,
+            throwOnError: false,
+        })));
+    }
+    static itemCacheEntryLooksUnhydratedAfterIdle(instance, props) {
+        const snap = instance.getService().getSnapshot();
+        if (snap.value !== 'idle')
+            return false;
+        const mapSize = snap.context.propertyInstances?.size ?? 0;
+        if (mapSize > 0)
+            return false;
+        const ctx = snap.context;
+        const versionsCount = props.versionsCount ?? ctx.versionsCount ?? 0;
+        const hasVersionHead = versionsCount > 0 ||
+            !!props.latestVersionLocalId ||
+            !!ctx.latestVersionLocalId ||
+            !!props.latestVersionUid ||
+            !!ctx.latestVersionUid;
+        return hasVersionHead;
+    }
     static async create(props, options) {
         const waitForReady = options?.waitForReady !== false;
         const readyTimeout = options?.readyTimeout ?? 5000;
@@ -11961,45 +13220,66 @@ class Item {
             props.modelName = startCase(props.type);
         }
         if (props.seedUid || props.seedLocalId) {
-            const seedId = (props.seedUid || props.seedLocalId);
-            if (this.instanceCache.has(seedId)) {
-                const { instance, refCount } = this.instanceCache.get(seedId);
-                this.instanceCache.set(seedId, {
-                    instance,
-                    refCount: refCount + 1,
-                });
-                for (const [propertyName, propertyValue] of Object.entries(props)) {
-                    const snapshot = instance.getService().getSnapshot();
-                    const propertyInstances = snapshot.context.propertyInstances;
-                    if (!propertyInstances || !propertyInstances.has(propertyName)) {
-                        continue;
-                    }
-                    const propertyInstance = propertyInstances.get(propertyName);
-                    if (!propertyInstance) {
-                        continue;
+            cacheReuse: {
+                const cachedEntry = this.findItemInstanceCacheEntryByProps(props);
+                if (cachedEntry) {
+                    const instance = cachedEntry.instance;
+                    cachedEntry.refCount += 1;
+                    for (const [propertyName, propertyValue] of Object.entries(props)) {
+                        const snapshot = instance.getService().getSnapshot();
+                        const propertyInstances = snapshot.context.propertyInstances;
+                        if (!propertyInstances || !propertyInstances.has(propertyName)) {
+                            continue;
+                        }
+                        const propertyInstance = propertyInstances.get(propertyName);
+                        if (!propertyInstance) {
+                            continue;
+                        }
+                        propertyInstance.getService().send({
+                            type: 'updateContext',
+                            propertyValue,
+                        });
                     }
-                    propertyInstance.getService().send({
-                        type: 'updateContext',
-                        propertyValue,
-                    });
-                }
-                if (!waitForReady)
-                    return instance;
-                try {
-                    await waitForEntityIdle(instance, { timeout: readyTimeout });
-                }
-                catch (err) {
+                    if (!waitForReady)
+                        return instance;
                     try {
-                        instance.unload();
+                        await this.waitForItemInstanceReadyForRead(instance, readyTimeout);
                     }
-                    catch {
-                        /* best-effort cache cleanup */
+                    catch (err) {
+                        try {
+                            instance.unload();
+                        }
+                        catch {
+                            /* best-effort cache cleanup */
+                        }
+                        throw err;
                     }
-                    throw err;
+                    if (waitForReady &&
+                        this.itemCacheEntryLooksUnhydratedAfterIdle(instance, props)) {
+                        forceRemoveFromCaches(instance, {
+                            getCacheKeys: () => this.collectInstanceCacheKeysForInstance(instance),
+                            caches: [Item.instanceCache],
+                        });
+                        try {
+                            unloadEntity(instance, {
+                                getCacheKeys: () => [],
+                                caches: [],
+                                instanceState: itemInstanceState,
+                                getService: (inst) => inst._service,
+                                onUnload: (inst) => {
+                                    inst._subscription?.unsubscribe();
+                                },
+                            });
+                        }
+                        catch {
+                            /* best-effort teardown for stale cached shell */
+                        }
+                        break cacheReuse;
+                    }
+                    return instance;
                 }
-                return instance;
             }
-            if (!this.instanceCache.has(seedId)) {
+            if (!this.findItemInstanceCacheEntryByProps(props)) {
                 // Item no longer needs modelInstance - it loads properties from database independently
                 // Exclude latestVersionUid from props as it has incompatible types (string vs VersionsType)
                 const { latestVersionUid, ...propsWithoutVersionUid } = props;
@@ -12088,14 +13368,11 @@ class Item {
                         return Reflect.getOwnPropertyDescriptor(target, prop);
                     },
                 });
-                this.instanceCache.set(seedId, {
-                    instance: proxiedInstance,
-                    refCount: 1,
-                });
+                this.registerItemInInstanceCache(proxiedInstance);
                 if (!waitForReady)
                     return proxiedInstance;
                 try {
-                    await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+                    await this.waitForItemInstanceReadyForRead(proxiedInstance, readyTimeout);
                 }
                 catch (err) {
                     try {
@@ -12271,14 +13548,11 @@ class Item {
                 return Reflect.getOwnPropertyDescriptor(target, prop);
             },
         });
-        this.instanceCache.set((proxiedInstance.seedUid || proxiedInstance.seedLocalId), {
-            instance: proxiedInstance,
-            refCount: 1,
-        });
+        this.registerItemInInstanceCache(proxiedInstance);
         if (!waitForReady)
             return proxiedInstance;
         try {
-            await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+            await this.waitForItemInstanceReadyForRead(proxiedInstance, readyTimeout);
         }
         catch (err) {
             try {
@@ -12301,14 +13575,10 @@ class Item {
         if (!id) {
             return null;
         }
-        // Check cache - the cache key is seedUid || seedLocalId
-        if (this.instanceCache.has(id)) {
-            const { instance, refCount } = this.instanceCache.get(id);
-            this.instanceCache.set(id, {
-                instance,
-                refCount: refCount + 1,
-            });
-            return instance;
+        const entry = this.findItemInstanceCacheEntryById(id);
+        if (entry) {
+            entry.refCount += 1;
+            return entry.instance;
         }
         return null;
     }
@@ -12354,8 +13624,8 @@ class Item {
         if (!seedLocalId && !seedUid) {
             return undefined;
         }
-        // Use seedUid as primary ID if available, otherwise use seedLocalId
-        const id = seedUid || seedLocalId;
+        // Prefer local id so cache + findEntity align with Item.instanceCache (local-first, uid alias).
+        const id = seedLocalId || seedUid;
         if (!id) {
             return undefined;
         }
@@ -12386,10 +13656,129 @@ class Item {
             }));
         }
         if (waitForReady && itemInstances.length > 0) {
-            await Promise.all(itemInstances.map((item) => waitForEntityIdle(item, { timeout: readyTimeout })));
+            await Promise.all(itemInstances.map((item) => this.waitForItemInstanceReadyForRead(item, readyTimeout)));
         }
         return orderBy(itemInstances, ['createdAt'], ['desc']);
     }
+    /**
+     * After EAS sync writes metadata for the latest version, merge new property instances and
+     * re-run DB hydration on cached Items. Item liveQuery watches seeds/versions, not metadata,
+     * and useItems may not invalidate when the seed set is unchanged.
+     */
+    static async rehydrateCachedItemsFromDbAfterEasSync() {
+        const appDb = BaseDb.getAppDb();
+        if (!appDb || Item.instanceCache.size === 0) {
+            return;
+        }
+        const _mod_8 = await import('./index-Bp0ChnQr.js');
+        const _ns_8 = _mod_8.s;
+        const { metadata } = _ns_8;
+        const { eq, and } = await import('drizzle-orm');
+        const dedupedInstances = new Map();
+        for (const entry of Item.instanceCache.values()) {
+            dedupedInstances.set(entry.instance, entry);
+        }
+        const entries = [...dedupedInstances.values()];
+        await Promise.all(entries.map(async ({ instance }) => {
+            try {
+                const svc = instance.getService();
+                if (svc.getSnapshot().status !== 'active') {
+                    return;
+                }
+                const ctx = svc.getSnapshot().context;
+                const seedLocalId = ctx.seedLocalId;
+                const seedUid = ctx.seedUid;
+                const versionLocalId = ctx.latestVersionLocalId;
+                const itemModelName = ctx.modelName;
+                const schemaNameForModel = ctx.schemaName;
+                if (!seedLocalId || !versionLocalId || !itemModelName) {
+                    return;
+                }
+                const metadataRows = await appDb
+                    .select()
+                    .from(metadata)
+                    .where(and(eq(metadata.seedLocalId, seedLocalId), eq(metadata.versionLocalId, versionLocalId)));
+                let propertySchemas = {};
+                try {
+                    const M = getModel();
+                    const model = schemaNameForModel !== undefined
+                        ? M?.getByName(itemModelName, schemaNameForModel)
+                        : M?.getByName(itemModelName);
+                    if (model?.properties?.length) {
+                        propertySchemas = modelPropertiesToObject(model.properties);
+                    }
+                }
+                catch {
+                    /* Model optional */
+                }
+                const sendToItemMachine = (event) => {
+                    if (svc.getSnapshot().status !== 'active') {
+                        return;
+                    }
+                    svc.send(event);
+                };
+                for (const metaRow of metadataRows) {
+                    try {
+                        let propertyName = metaRow.propertyName;
+                        const listSchemaKey = propertyName &&
+                            Object.keys(propertySchemas).length > 0 &&
+                            resolveStorageNameToSchemaName(propertySchemas, propertyName);
+                        if (listSchemaKey) {
+                            propertyName = listSchemaKey;
+                        }
+                        else {
+                            const baseName = propertyName?.endsWith('Id') ? propertyName.slice(0, -2) : undefined;
+                            const refSeedType = metaRow.refSeedType;
+                            const isRefTypeFromMeta = refSeedType === 'file' ||
+                                refSeedType === 'image' ||
+                                refSeedType === 'relation' ||
+                                refSeedType === 'html';
+                            if (baseName && (propertySchemas[baseName] || isRefTypeFromMeta)) {
+                                propertyName = baseName;
+                            }
+                        }
+                        if (!propertyName) {
+                            continue;
+                        }
+                        const property = await ItemProperty.find({
+                            propertyName,
+                            seedLocalId,
+                            seedUid,
+                            modelName: itemModelName,
+                        });
+                        if (property) {
+                            sendToItemMachine({
+                                type: 'addPropertyInstance',
+                                propertyName,
+                                propertyInstance: property,
+                            });
+                        }
+                    }
+                    catch {
+                        /* row skipped */
+                    }
+                }
+                const instances = svc.getSnapshot().context.propertyInstances;
+                if (!instances) {
+                    return;
+                }
+                for (const propertyInstance of instances.values()) {
+                    try {
+                        const propertySnap = propertyInstance.getService().getSnapshot();
+                        if (isMachineSnapshot(propertySnap) && propertySnap.matches('idle')) {
+                            propertyInstance.getService().send({ type: 'rehydrateFromDb' });
+                        }
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                }
+            }
+            catch (e) {
+                itemLogger('rehydrateCachedItemsFromDbAfterEasSync item failed:', e);
+            }
+        }));
+    }
     _createPropertyInstance(props) {
         if (this._storageTransactionId) {
             props.storageTransactionId = this._storageTransactionId;
@@ -12732,9 +14121,9 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_8 = await import('./index-DdzhrbkF.js');
-                const _ns_8 = _mod_8.s;
-                const seedSchemaMod = _ns_8;
+                const _mod_9 = await import('./index-Bp0ChnQr.js');
+                const _ns_9 = _mod_9.s;
+                const seedSchemaMod = _ns_9;
                 const { seeds, versions, metadata } = seedSchemaMod;
                 const drizzleMod = await import('drizzle-orm');
                 const { eq, and } = drizzleMod;
@@ -13006,15 +14395,10 @@ class Item {
     }
     unload() {
         try {
-            const context = this._getSnapshotContext();
-            const cacheKey = context.seedUid || context.seedLocalId;
-            const cacheKeys = [];
-            if (cacheKey) {
-                cacheKeys.push(cacheKey);
-            }
+            Item.releaseItemInstanceCacheHold(this);
             unloadEntity(this, {
-                getCacheKeys: () => cacheKeys,
-                caches: [Item.instanceCache],
+                getCacheKeys: () => [],
+                caches: [],
                 instanceState: itemInstanceState,
                 getService: (instance) => instance._service,
                 onUnload: (instance) => {
@@ -13043,11 +14427,10 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await import('./ownership-BK6suksO.js');
+        const { assertItemOwned } = await import('./ownership-D-KsIkxM.js');
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
-        const cacheKey = context.seedUid || context.seedLocalId;
-        const cacheKeys = cacheKey ? [cacheKey] : [];
+        const cacheKeys = Item.collectInstanceCacheKeysForInstance(this);
         clearDestroySubscriptions(this, {
             instanceState: itemInstanceState,
             onUnload: (instance) => instance._subscription?.unsubscribe(),
@@ -13104,600 +14487,331 @@ function normalizeAddressConfig(addresses) {
     };
 }
 
-// Dynamic import to break circular dependency: Model -> BaseItem -> ... -> getModelSchemas -> Model
-// import { Model } from '@/Model/Model'
-const schemaStringToModelRecord = new Map();
-const getModelSchemas = async () => {
-    // Dynamic import to break circular dependency
-    const modelMod = await Promise.resolve().then(function () { return Model$1; });
-    const { Model } = modelMod;
-    const allModels = await Model.all();
-    const modelRecords = [];
-    const appDb = BaseDb.getAppDb();
-    for (const model of allModels) {
-        const modelName = model.modelName;
-        if (!modelName)
-            continue;
-        const foundModelQuery = await appDb
-            .select({
-            id: models$1.id,
-            name: models$1.name,
-            uid: modelUids.uid,
+let writeTail = Promise.resolve();
+function enqueueEasSyncDbWrite(fn) {
+    const next = writeTail.then(fn);
+    writeTail = next.catch(() => { });
+    return next;
+}
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+const MAX_ERROR_DETAILS_LENGTH = 2000;
+async function insertEasSyncProcessRow(params) {
+    return enqueueEasSyncDbWrite(async () => {
+        const db = BaseDb.getAppDb();
+        if (!db) {
+            throw new Error('[easSyncProcess] App DB not available');
+        }
+        const now = Date.now();
+        const [row] = await db
+            .insert(easSyncProcesses)
+            .values({
+            status: 'in_progress',
+            startedAt: now,
+            requestPayload: JSON.stringify(params.requestPayload),
+            persistedSnapshot: JSON.stringify(params.persistedSnapshot),
+            createdAt: now,
+            updatedAt: now,
         })
-            .from(models$1)
-            .leftJoin(modelUids, eq(models$1.id, modelUids.modelId))
-            .where(eq(models$1.name, modelName))
-            .limit(1);
-        if (!foundModelQuery[0]) {
-            console.error(`[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`);
-            continue;
-        }
-        const foundModel = {
-            id: foundModelQuery[0].id,
-            name: foundModelQuery[0].name,
-            uid: foundModelQuery[0].uid,
-            tableName: pluralize(foundModelQuery[0].name).toLowerCase(),
-        };
-        modelRecords.push(foundModel);
-        if (modelName === 'Seed') {
-            continue;
-        }
-        const schemaString = `bytes32 ${toSnakeCase(modelName)}`;
-        schemaStringToModelRecord.set(schemaString, foundModel);
-    }
-    return {
-        schemaStringToModelRecord,
-        modelRecords,
-    };
-};
-
-const createSeeds = async (newSeeds) => {
-    const appDb = BaseDb.getAppDb();
-    const results = await appDb
-        .insert(seeds)
-        .values(newSeeds)
-        .returning({ uid: seeds.uid });
-    const newUids = results.reduce((acc, result) => {
-        if (result.uid) {
-            acc.push(result.uid);
+            .returning({ id: easSyncProcesses.id });
+        return row.id;
+    });
+}
+async function finalizeEasSyncProcessRow(id, params) {
+    return enqueueEasSyncDbWrite(async () => {
+        const db = BaseDb.getAppDb();
+        if (!db) {
+            return;
         }
-        return acc;
-    }, []);
-    return newUids;
-};
+        const now = Date.now();
+        await db
+            .update(easSyncProcesses)
+            .set({
+            status: params.status,
+            completedAt: now,
+            updatedAt: now,
+            errorMessage: params.errorMessage?.slice(0, MAX_ERROR_MESSAGE_LENGTH) ?? null,
+            errorDetails: params.errorDetails?.slice(0, MAX_ERROR_DETAILS_LENGTH) ?? null,
+            persistedSnapshot: JSON.stringify(params.persistedSnapshot),
+        })
+            .where(eq(easSyncProcesses.id, id));
+    });
+}
 
 /**
- * Sets revokedAt timestamp on a seed record after attestations have been revoked on EAS.
+ * Merge multiple EAS sync intents: full sync (no concrete address list) wins;
+ * otherwise union addresses (first-seen casing).
  */
-const updateSeedRevokedAt = async ({ seedLocalId, revokedAt, }) => {
-    if (!seedLocalId) {
-        return;
+function mergeEasSyncRequestIntents(parts) {
+    const norm = parts.filter((p) => p != null);
+    if (norm.length === 0) {
+        return {};
     }
-    const appDb = BaseDb.getAppDb();
-    await appDb
-        .update(seeds)
-        .set({
-        revokedAt,
-        updatedAt: Date.now(),
-    })
-        .where(eq(seeds.localId, seedLocalId));
-};
-
-const relationValuesToExclude = [
-    '0x0000000000000000000000000000000000000000000000000000000000000020',
-];
-const seedUidToLocalId = new Map();
-const seedUidToModelType = new Map();
-const relatedSeedUids = new Set();
-const versionUidToLocalId = new Map();
-const versionUidToSeedUid = new Map();
-const propertyUidToLocalId = new Map();
-const saveEasSeedsToDb = async ({ itemSeeds }) => {
-    const appDb = BaseDb.getAppDb();
-    const seedUids = itemSeeds.map((seed) => seed.id);
-    const existingSeedRecordsRows = await appDb
-        .select()
-        .from(seeds)
-        .where(inArray(seeds.uid, seedUids));
-    const existingSeedUids = new Set();
-    if (existingSeedRecordsRows && existingSeedRecordsRows.length > 0) {
-        for (const row of existingSeedRecordsRows) {
-            if (row.uid) {
-                existingSeedUids.add(row.uid);
-                if (row.localId) {
-                    seedUidToLocalId.set(row.uid, row.localId);
-                }
-                if (row.type) {
-                    seedUidToModelType.set(row.uid, row.type);
-                }
+    let full = false;
+    const addressMap = new Map();
+    for (const p of norm) {
+        if (!('addresses' in p) || p.addresses === undefined) {
+            full = true;
+            break;
+        }
+        for (const addr of p.addresses) {
+            const k = addr.toLowerCase();
+            if (!addressMap.has(k)) {
+                addressMap.set(k, addr);
             }
         }
     }
-    const newSeeds = itemSeeds.filter((seed) => !existingSeedUids.has(seed.id));
-    // Update existing seeds when attestations are revoked on EAS
-    const seedByUid = new Map(itemSeeds.map((s) => [s.id, s]));
-    for (const row of existingSeedRecordsRows) {
-        if (!row.uid || !row.localId)
-            continue;
-        const attestation = seedByUid.get(row.uid);
-        if (!attestation?.revoked)
-            continue;
-        if (row.revokedAt != null)
-            continue;
-        const revokedAt = attestation.revocationTime > 0
-            ? attestation.revocationTime
-            : Math.floor(Date.now() / 1000);
-        await updateSeedRevokedAt({ seedLocalId: row.localId, revokedAt });
-    }
-    if (newSeeds.length === 0) {
-        return { seedUidToLocalId, seedUids };
-    }
-    const newSeedsData = [];
-    for (let i = 0; i < newSeeds.length; i++) {
-        const seed = newSeeds[i];
-        seedUidToModelType.set(seed.id, seed.schema.schemaNames[0].name);
-        const seedLocalId = generateId();
-        seedUidToLocalId.set(seed.id, seedLocalId);
-        const attestationRaw = escapeSqliteString(JSON.stringify(seed));
-        const revokedAt = seed.revoked && seed.revocationTime != null && seed.revocationTime > 0
-            ? seed.revocationTime
-            : seed.revoked
-                ? Math.floor(Date.now() / 1000)
-                : undefined;
-        newSeedsData.push({
-            localId: seedLocalId,
-            uid: seed.id,
-            schemaUid: seed.schemaId,
-            type: seed.schema.schemaNames[0].name,
-            publisher: seed.attester,
-            createdAt: Date.now(),
-            attestationCreatedAt: seed.timeCreated * 1000,
-            attestationRaw,
-            ...(revokedAt !== undefined && { revokedAt }),
-        });
-        seedUidToLocalId.set(seed.id, seedLocalId);
+    if (full) {
+        return {};
     }
-    const newSeedUids = await createSeeds(newSeedsData);
-    return { seedUids: newSeedUids };
-};
-const saveEasVersionsToDb = async ({ itemVersions }) => {
-    const versionUids = itemVersions.map((version) => version.id);
-    const appDb = BaseDb.getAppDb();
-    const existingVersionRecordsRows = await appDb
-        .select()
-        .from(versions)
-        .where(inArray(versions.uid, versionUids));
-    const existingVersionUids = new Set();
-    if (existingVersionRecordsRows && existingVersionRecordsRows.length > 0) {
-        for (const row of existingVersionRecordsRows) {
-            if (row.uid) {
-                existingVersionUids.add(row.uid);
-                if (row.localId) {
-                    versionUidToLocalId.set(row.uid, row.localId);
-                }
-                if (row.seedUid) {
-                    versionUidToSeedUid.set(row.uid, row.seedUid);
-                }
-            }
-        }
-    }
-    const newVersions = itemVersions.filter((version) => !existingVersionUids.has(version.id));
-    if (newVersions.length === 0) {
-        return { versionUidToLocalId, versionUids };
-    }
-    let insertVersionsQuery = `INSERT INTO versions (local_id, uid, seed_uid, seed_local_id, seed_type, created_at,
-                                                   attestation_created_at,
-                                                   attestation_raw, publisher)
-  VALUES `;
-    for (let i = 0; i < newVersions.length; i++) {
-        const version = newVersions[i];
-        versionUidToSeedUid.set(version.id, version.refUID);
-        const versionLocalId = generateId();
-        versionUidToLocalId.set(version.id, versionLocalId);
-        const seedUid = versionUidToSeedUid.get(version.id);
-        const seedLocalId = seedUidToLocalId.get(seedUid);
-        const seedType = seedUidToModelType.get(seedUid);
-        const attestationRaw = escapeSqliteString(JSON.stringify(version));
-        const publisher = escapeSqliteString(version.attester ?? '');
-        const valuesString = `('${versionLocalId}', '${version.id}', '${seedUid}', '${seedLocalId}', '${seedType}', ${Date.now()}, ${version.timeCreated * 1000}, '${attestationRaw}', '${publisher}')`;
-        if (i < newVersions.length - 1) {
-            insertVersionsQuery += valuesString + ', ';
-        }
-        if (i === newVersions.length - 1) {
-            insertVersionsQuery += valuesString + ';';
-        }
-        versionUidToLocalId.set(version.id, versionLocalId);
-    }
-    await appDb.run(sql.raw(insertVersionsQuery));
-    return { versionUids };
-};
-const createMetadataRecordsForStorageTransactionId = async (storageTransactionIdProperty, modelSchema) => {
-    // Early return if modelSchema is not provided
-    if (!modelSchema) {
-        console.warn('[item/events] [syncDbWithEas] modelSchema is undefined for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
-        return;
+    if (addressMap.size === 0) {
+        return { addresses: [] };
     }
-    // Validate and parse decodedDataJson
-    if (!storageTransactionIdProperty.decodedDataJson || storageTransactionIdProperty.decodedDataJson.trim() === '') {
-        console.warn('[item/events] [syncDbWithEas] empty decodedDataJson for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
-        return;
+    return { addresses: [...addressMap.values()] };
+}
+
+const log = debug('seedSdk:events:easSyncManager');
+function toRunSyncArg(options) {
+    if (options &&
+        'addresses' in options &&
+        options.addresses !== undefined) {
+        return options;
     }
-    let parsedData;
+    return undefined;
+}
+const runEasSync = fromPromise(async ({ input, }) => {
+    const rowId = await insertEasSyncProcessRow({
+        requestPayload: input.requestPayload,
+        persistedSnapshot: input.runningSnapshot,
+    });
+    const { runSyncFromEas } = await import('./syncDbWithEas-m-_3Ds7d.js');
     try {
-        parsedData = JSON.parse(storageTransactionIdProperty.decodedDataJson);
-    }
-    catch (error) {
-        console.warn('[item/events] [syncDbWithEas] failed to parse decodedDataJson for storageTransactionIdProperty: ', storageTransactionIdProperty.id, error);
-        return;
-    }
-    if (!Array.isArray(parsedData) || parsedData.length === 0 || !parsedData[0]?.value) {
-        console.warn('[item/events] [syncDbWithEas] invalid decodedDataJson structure for storageTransactionIdProperty: ', storageTransactionIdProperty.id);
-        return;
-    }
-    const attestationData = parsedData[0].value;
-    camelCase(attestationData.name);
-    const propertyValue = attestationData.value;
-    const itemStorageProperties = new Map();
-    for (const [_propertyName, propertyDef] of Object.entries(modelSchema)) {
-        if (propertyDef?.storageType && propertyDef.storageType === 'ItemStorage') {
-            itemStorageProperties.set(_propertyName, propertyDef);
-        }
-    }
-    if (itemStorageProperties.size === 0) {
-        return;
-    }
-    const appDb = BaseDb.getAppDb();
-    for (const [_propertyName, propertyDef] of itemStorageProperties.entries()) {
-        const existingMetadataRecordRows = await appDb
-            .select()
-            .from(metadata$1)
-            .where(and(eq(metadata$1.propertyName, _propertyName), eq(metadata$1.propertyValue, propertyValue), eq(metadata$1.versionUid, storageTransactionIdProperty.refUID)));
-        if (existingMetadataRecordRows && existingMetadataRecordRows.length > 0) {
-            continue;
-        }
-        const seedUid = versionUidToSeedUid.get(storageTransactionIdProperty.refUID);
-        const seedLocalId = seedUidToLocalId.get(seedUid);
-        const versionUid = storageTransactionIdProperty.refUID;
-        const versionLocalId = versionUidToLocalId.get(versionUid);
-        const modelType = seedUidToModelType.get(seedUid);
-        const propertyId = modelType != null
-            ? await getPropertyIdForModelAndName(modelType, _propertyName)
-            : null;
-        const propertyLocalId = generateId();
-        await appDb.insert(metadata$1).values({
-            localId: propertyLocalId,
-            propertyId: propertyId ?? undefined,
-            propertyName: _propertyName,
-            propertyValue,
-            localStorageDir: propertyDef.localStorageDir,
-            seedLocalId,
-            seedUid,
-            versionLocalId,
-            versionUid,
-            refValueType: 'file',
-            refResolvedValue: `${propertyValue}${propertyDef.filenameSuffix}`,
-            modelType: seedUidToModelType.get(seedUid),
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
+        await runSyncFromEas(toRunSyncArg(input.options));
+        await finalizeEasSyncProcessRow(rowId, {
+            status: 'completed',
+            persistedSnapshot: {
+                phase: 'completed',
+                correlationIds: input.requestPayload.correlationIds,
+            },
         });
     }
-};
-let isSavingToDb = false;
-const saveEasPropertiesToDb = async ({ itemProperties, itemSeeds, }) => {
-    if (isSavingToDb) {
-        return { propertyUids: [] };
-    }
-    isSavingToDb = true;
-    const propertyUids = itemProperties.map((property) => property.id);
-    // Dynamic import to break circular dependency
-    const modelMod = await Promise.resolve().then(function () { return Model$1; });
-    const { Model } = modelMod;
-    const allModels = await Model.all();
-    const models = Object.fromEntries(allModels.map(m => [m.modelName, m]));
-    const appDb = BaseDb.getAppDb();
-    const existingMetadataRecordsRows = await appDb
-        .select()
-        .from(metadata$1)
-        .where(inArray(metadata$1.uid, propertyUids));
-    const existingPropertyRecordsUids = new Set();
-    if (existingMetadataRecordsRows && existingMetadataRecordsRows.length > 0) {
-        for (const row of existingMetadataRecordsRows) {
-            if (row.uid) {
-                existingPropertyRecordsUids.add(row.uid);
-                if (row.localId) {
-                    propertyUidToLocalId.set(row.uid, row.localId);
-                }
-            }
-        }
-    }
-    const newProperties = itemProperties.filter((property) => !existingPropertyRecordsUids.has(property.id));
-    if (newProperties.length === 0) {
-        return { propertyUidToLocalId, propertyUids };
-    }
-    let insertPropertiesQuery = `INSERT INTO metadata (local_id, uid, schema_uid, property_id, property_name, property_value,
-                                                     eas_data_type, version_uid, version_local_id, seed_uid,
-                                                     seed_local_id, model_type, ref_value_type, ref_seed_type,
-                                                     ref_schema_uid,
-                                                     created_at, attestation_created_at, attestation_raw,
-                                                     local_storage_dir, ref_resolved_value, publisher)
-  VALUES `;
-    for (let i = 0; i < newProperties.length; i++) {
-        const property = newProperties[i];
-        const propertyLocalId = generateId();
-        // Validate and parse decodedDataJson
-        if (!property.decodedDataJson || property.decodedDataJson.trim() === '') {
-            console.warn('[item/events] [syncDbWithEas] empty decodedDataJson for property: ', property.id);
-            continue;
-        }
-        let parsedData;
-        try {
-            parsedData = JSON.parse(property.decodedDataJson);
-        }
-        catch (error) {
-            console.warn('[item/events] [syncDbWithEas] failed to parse decodedDataJson for property: ', property.id, error);
-            continue;
-        }
-        if (!Array.isArray(parsedData) || parsedData.length === 0 || !parsedData[0]?.value) {
-            console.warn('[item/events] [syncDbWithEas] invalid decodedDataJson structure for property: ', property.id);
-            continue;
-        }
-        const metadata = parsedData[0].value;
-        let propertyNameSnake = metadata.name;
-        if (!propertyNameSnake) {
-            console.warn('[item/events] [syncDbWithEas] no propertyName found for property: ', property);
-            continue;
-        }
-        let isRelation = false;
-        let refValueType;
-        let refSeedType;
-        let refSchemaUid;
-        let isList = false;
-        const schemaUid = property.schemaId;
-        setSchemaUidForSchemaDefinition({
-            text: propertyNameSnake,
-            schemaUid,
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const details = err instanceof Error && err.stack
+            ? err.stack.slice(0, 2000)
+            : undefined;
+        await finalizeEasSyncProcessRow(rowId, {
+            status: 'failed',
+            errorMessage: message,
+            errorDetails: details,
+            persistedSnapshot: {
+                phase: 'failed',
+                correlationIds: input.requestPayload.correlationIds,
+            },
         });
-        if ((propertyNameSnake.endsWith('_id') ||
-            propertyNameSnake.endsWith('_ids')) &&
-            propertyNameSnake !== 'storage_transaction_id' &&
-            propertyNameSnake !== 'storage_provider_transaction_id') {
-            isRelation = true;
-            if (Array.isArray(metadata.value)) {
-                isList = true;
-                refValueType = 'list';
-                const result = parseEasRelationPropertyName(propertyNameSnake);
-                if (result) {
-                    propertyNameSnake = result.propertyName;
-                    refSeedType = result.modelName;
-                }
-                metadata.value.forEach((value) => {
-                    relatedSeedUids.add(value);
-                });
-            }
-            if (!isList) {
-                if (relationValuesToExclude.includes(metadata.value)) {
-                    continue;
-                }
-                relatedSeedUids.add(metadata.value);
-            }
-        }
-        let propertyValue = metadata.value;
-        if (typeof propertyValue !== 'string') {
-            propertyValue = JSON.stringify(propertyValue);
-        }
-        if (isRelation && !isList) {
-            const relatedSeed = itemSeeds.find((seed) => seed.id === metadata.value);
-            if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
-                refSeedType = relatedSeed.schema.schemaNames[0].name;
-                refSchemaUid = relatedSeed.schemaId;
-            }
-        }
-        if (isRelation && isList) {
-            const relatedSeeds = itemSeeds.filter((seed) => metadata.value.includes(seed.id));
-            if (relatedSeeds && relatedSeeds.length > 0) {
-                refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
-                refSchemaUid = relatedSeeds[0].schemaId;
-            }
-        }
-        const propertyName = camelCase(propertyNameSnake);
-        propertyValue = escapeSqliteString(propertyValue);
-        const easDataType = metadata.type;
-        const versionUid = property.refUID;
-        const versionLocalId = versionUidToLocalId.get(versionUid);
-        const attestationCreatedAt = property.timeCreated * 1000;
-        const attestationRaw = escapeSqliteString(JSON.stringify(property));
-        const seedUid = versionUidToSeedUid.get(versionUid);
-        const seedLocalId = seedUidToLocalId.get(seedUid);
-        const modelType = seedUidToModelType.get(seedUid);
-        const modelName = startCase(modelType);
-        const model = models[modelName];
-        const modelSchema = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
-        if (propertyNameSnake === 'storage_transaction_id') {
-            await createMetadataRecordsForStorageTransactionId(property, modelSchema);
-        }
-        const propertyId = modelType != null
-            ? await getPropertyIdForModelAndName(modelType, propertyName)
-            : null;
-        const propertyIdSql = propertyId != null ? String(propertyId) : 'NULL';
-        const publisher = escapeSqliteString(property.attester ?? '');
-        const valuesString = `('${propertyLocalId}', '${property.id}', 
-                         '${property.schemaId}', ${propertyIdSql}, '${propertyName}', 
-                         '${propertyValue}', '${easDataType}', '${versionUid}', 
-                         '${versionLocalId}', '${seedUid}', '${seedLocalId}', 
-                         '${modelType}', ${refValueType ? `'${refValueType}'` : 'NULL'}, 
-                         ${refSeedType ? `'${refSeedType}'` : 'NULL'},
-                         ${refSchemaUid ? `'${refSchemaUid}'` : 'NULL'},
-                         ${Date.now()}, ${attestationCreatedAt}, '${attestationRaw}',
-                         ${'NULL'},
-                         ${'NULL'},
-                         '${publisher}')`;
-        if (i < newProperties.length - 1) {
-            insertPropertiesQuery += valuesString + ', ';
-        }
-        if (i === newProperties.length - 1) {
-            insertPropertiesQuery += valuesString + ';';
-        }
-        propertyUidToLocalId.set(property.id, propertyLocalId);
-    }
-    if (insertPropertiesQuery.endsWith('VALUES ')) {
-        return { propertyUids };
-    }
-    if (insertPropertiesQuery.endsWith(', ')) {
-        insertPropertiesQuery = insertPropertiesQuery.slice(0, -2) + ';';
-    }
-    await appDb.run(sql.raw(insertPropertiesQuery));
-    isSavingToDb = false;
-    return { propertyUids };
+        throw err;
+    }
+});
+const initialContext = {
+    runOptions: {},
+    activeCorrelationIds: [],
+    activePrimarySource: 'event_bus',
+    pendingMergedOptions: undefined,
+    pendingCorrelationIds: [],
+    pendingPrimarySource: null,
+    lastFinishedCorrelationIds: null,
+    lastFinishedStatus: null,
+    lastFinishedError: null,
 };
-const getRelatedSeedsAndVersions = async () => {
-    BaseQueryClient.getQueryClient();
-    const easClient = BaseEasClient.getEasClient();
-    const { itemSeeds } = await easClient.request(GET_SEEDS, {
-        where: {
-            id: {
-                in: Array.from(relatedSeedUids),
+const easSyncMachine = setup({
+    types: {
+        context: {},
+        events: {},
+    },
+    actors: {
+        runEasSync,
+    },
+}).createMachine({
+    id: MachineIds.EAS_SYNC_MANAGER,
+    initial: 'idle',
+    context: initialContext,
+    states: {
+        idle: {
+            on: {
+                REQUEST: {
+                    target: 'running',
+                    actions: assign({
+                        runOptions: ({ event }) => event.options === undefined
+                            ? {}
+                            : mergeEasSyncRequestIntents([event.options]),
+                        activeCorrelationIds: ({ event }) => [event.correlationId],
+                        activePrimarySource: ({ event }) => event.source,
+                    }),
+                },
+            },
+        },
+        running: {
+            on: {
+                REQUEST: {
+                    actions: assign({
+                        pendingMergedOptions: ({ context, event }) => mergeEasSyncRequestIntents([
+                            context.runOptions,
+                            context.pendingMergedOptions,
+                            event.options === undefined ? {} : event.options,
+                        ].filter((x) => x != null)),
+                        pendingCorrelationIds: ({ context, event }) => [
+                            ...context.pendingCorrelationIds,
+                            event.correlationId,
+                        ],
+                        pendingPrimarySource: ({ context, event }) => context.pendingPrimarySource ?? event.source,
+                    }),
+                },
             },
-        },
-    });
-    await saveEasSeedsToDb({ itemSeeds });
-    const { itemVersions } = await easClient.request(GET_VERSIONS, {
-        where: {
-            refUID: {
-                in: Array.from(relatedSeedUids),
+            invoke: {
+                src: 'runEasSync',
+                input: ({ context }) => ({
+                    options: context.runOptions,
+                    requestPayload: {
+                        source: context.activePrimarySource,
+                        correlationIds: context.activeCorrelationIds,
+                        options: context.runOptions,
+                    },
+                    runningSnapshot: {
+                        phase: 'running',
+                        correlationIds: context.activeCorrelationIds,
+                    },
+                }),
+                onDone: {
+                    target: 'afterRun',
+                    actions: assign({
+                        lastFinishedCorrelationIds: ({ context }) => [
+                            ...context.activeCorrelationIds,
+                        ],
+                        lastFinishedStatus: () => 'success',
+                        lastFinishedError: () => null,
+                        activeCorrelationIds: () => [],
+                        runOptions: () => ({}),
+                    }),
+                },
+                onError: {
+                    target: 'afterRun',
+                    actions: [
+                        assign({
+                            lastFinishedCorrelationIds: ({ context }) => [
+                                ...context.activeCorrelationIds,
+                            ],
+                            lastFinishedStatus: () => 'failed',
+                            lastFinishedError: ({ event }) => {
+                                const e = event.error;
+                                if (e instanceof Error) {
+                                    return e.message;
+                                }
+                                return e != null ? String(e) : 'EAS sync failed';
+                            },
+                            activeCorrelationIds: () => [],
+                            runOptions: () => ({}),
+                        }),
+                        ({ event }) => {
+                            log('runEasSync error', event.error);
+                        },
+                    ],
+                },
             },
         },
-    });
-    await saveEasVersionsToDb({ itemVersions });
-    const relatedVersionUids = itemVersions.map((v) => v.id);
-    const { itemProperties } = await easClient.request(GET_PROPERTIES, {
-        where: {
-            refUID: {
-                in: relatedVersionUids,
-            },
+        afterRun: {
+            always: [
+                {
+                    guard: ({ context }) => context.pendingCorrelationIds.length > 0,
+                    target: 'running',
+                    actions: assign({
+                        runOptions: ({ context }) => mergeEasSyncRequestIntents([context.pendingMergedOptions]),
+                        activeCorrelationIds: ({ context }) => [
+                            ...context.pendingCorrelationIds,
+                        ],
+                        activePrimarySource: ({ context }) => context.pendingPrimarySource ?? 'event_bus',
+                        pendingMergedOptions: () => undefined,
+                        pendingCorrelationIds: () => [],
+                        pendingPrimarySource: () => null,
+                    }),
+                },
+                { target: 'idle' },
+            ],
         },
-    });
-    await saveEasPropertiesToDb({
-        itemProperties,
-        itemSeeds,
-    });
-};
-/**
- * Core sync logic: fetches item attestations from EAS for configured models and given addresses,
- * then saves seeds, versions, and properties to the local DB.
- * Uses owned + watched addresses from DB when addresses are not provided.
- */
-const runSyncFromEas = async (options) => {
-    let addresses = options?.addresses ?? (await getAllAddressesFromDb());
-    const additionalGetter = getGetAdditionalSyncAddresses();
-    if (additionalGetter) {
-        const additional = await additionalGetter();
-        if (additional?.length) {
-            const seen = new Set(addresses.map((a) => a.toLowerCase()));
-            for (const addr of additional) {
-                if (addr && !seen.has(addr.toLowerCase())) {
-                    seen.add(addr.toLowerCase());
-                    addresses = [...addresses, addr];
-                }
-            }
-        }
-    }
-    if (!addresses || addresses.length === 0) {
+    },
+});
+const easSyncActor = createActor(easSyncMachine);
+let easSyncActorStarted = false;
+function startEasSyncActor() {
+    if (easSyncActorStarted) {
         return;
     }
-    const appDb = BaseDb.getAppDb();
-    const { schemaStringToModelRecord } = await getModelSchemas();
-    const modelSchemas = await getModelSchemasFromEas();
-    const schemaUids = [];
-    for (const modelSchema of modelSchemas) {
-        const foundModel = schemaStringToModelRecord.get(modelSchema.schema);
-        if (!foundModel) {
-            // Skip schemas that don't have a corresponding model in the user's config
-            // This can happen with "bytes32 image" if there's no Image model defined
-            console.warn(`[item/events] [syncDbWithEas] Model not found for schema ${modelSchema.schema}, skipping`);
-            continue;
-        }
-        try {
-            await appDb
-                .insert(modelUids)
-                .values({
-                modelId: foundModel.id,
-                uid: modelSchema.id,
-            })
-                .onConflictDoNothing();
-        }
-        catch (err) {
-            // Model may have been deleted by test teardown or another process; skip to avoid unhandled rejection
-            const e = err;
-            const code = e?.code ?? e?.rawCode ?? e?.cause?.code ?? e?.cause?.rawCode;
-            if (code === 'SQLITE_CONSTRAINT_FOREIGNKEY' || code === 787) {
-                continue;
-            }
-            throw err;
-        }
-        schemaUids.push(modelSchema.id);
-    }
-    // If no schemas were found, skip the rest of the sync process
-    // This can happen when models exist but don't have schemas registered in EAS yet
-    if (schemaUids.length === 0) {
-        return;
+    easSyncActorStarted = true;
+    easSyncActor.start();
+}
+function newCorrelationId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID) {
+        return c.randomUUID();
     }
-    const itemSeeds = await getSeedsFromSchemaUids({
-        schemaUids,
-        addresses,
-        excludeRevoked: false,
-    });
-    const { seedUids } = await saveEasSeedsToDb({
-        itemSeeds,
-    });
-    const itemVersions = await getItemVersionsFromEas({
-        seedUids,
-        excludeRevoked: false,
+    return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function requestEasSyncFromEventBus() {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        source: 'event_bus',
     });
-    const { versionUids } = await saveEasVersionsToDb({
-        itemVersions,
+}
+function requestEasSyncFromAddressChange(addresses) {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        options: { addresses },
+        source: 'address_change',
     });
-    const rawProperties = await getItemPropertiesFromEas({
-        versionUids,
-        excludeRevoked: false,
+}
+function requestEasSyncFromModelsInit() {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId: newCorrelationId(),
+        source: 'models_init',
     });
-    const itemProperties = pickLatestPropertyAttestationsByRefAndSchema(rawProperties);
-    await saveEasPropertiesToDb({
-        itemProperties,
-        itemSeeds,
+}
+function sendEasSyncClientRequest(correlationId, options) {
+    startEasSyncActor();
+    easSyncActor.send({
+        type: 'REQUEST',
+        correlationId,
+        options,
+        source: 'client_api',
     });
-    await getRelatedSeedsAndVersions();
-};
-const syncDbWithEasHandler = throttle(async (_) => {
-    await runSyncFromEas();
-}, 30000, {
-    leading: true,
-    trailing: false,
-});
+}
 
-const isNode = () => {
-    return (typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null);
-};
-const isBrowser = () => {
-    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
-};
-const isElectron = () => {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
-};
+var easSyncManager = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    easSyncActor: easSyncActor,
+    easSyncMachine: easSyncMachine,
+    requestEasSyncFromAddressChange: requestEasSyncFromAddressChange,
+    requestEasSyncFromEventBus: requestEasSyncFromEventBus,
+    requestEasSyncFromModelsInit: requestEasSyncFromModelsInit,
+    sendEasSyncClientRequest: sendEasSyncClientRequest,
+    startEasSyncActor: startEasSyncActor
+});
 
 /**
  * @deprecated Use BaseArweaveClient.setHost() instead.
  * This function is kept for backward compatibility but will be removed in a future version.
  */
 const setArweaveDomain = (newDomain) => {
-    BaseArweaveClient.setHost(newDomain);
+    BaseArweaveClient.setPreferredReadGateway(newDomain);
 };
 
-const logger$c = debug('seedSdk:services:events');
+const logger$b = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$c(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$b(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     // TODO: This is called from Node as well. Do we need it? If so, need to generalize this to all platforms.
     // localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
 };
@@ -13706,7 +14820,8 @@ const setupServicesEventHandlers = () => {
 };
 
 const setupAllItemsEventHandlers = () => {
-    eventEmitter.addListener('syncDbWithEas', syncDbWithEasHandler);
+    startEasSyncActor();
+    eventEmitter.addListener('syncDbWithEas', requestEasSyncFromEventBus);
 };
 // Note: getAreItemEventHandlersReady removed - was only used by useItemIsReady hook which has been removed
 
@@ -13740,9 +14855,9 @@ class BasePathResolver {
     }
 }
 
-const logger$b = debug('seedSdk:ClientManager:initialize');
+const logger$a = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$b('initialize from ClientManager');
+    logger$a('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -13778,20 +14893,20 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         let PathResolver;
         let EasClient;
         if (isBrowser()) {
-            FileManager = (await import('./FileManager-DHnyb040.js')).FileManager;
-            Db = (await import('./Db-CXwQVLZv.js')).Db;
-            QueryClient = (await import('./QueryClient-unspcsWa.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-Cz9ZLiEV.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-pmw--Ea2.js')).PathResolver;
-            EasClient = (await import('./EasClient-DjpbHjU9.js')).EasClient;
+            FileManager = (await import('./FileManager-BOxbzROS.js')).FileManager;
+            Db = (await import('./Db-DA_e7Jcc.js')).Db;
+            QueryClient = (await import('./QueryClient-B12y2daD.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-KF_T3NSr.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-DHTAlCzo.js')).PathResolver;
+            EasClient = (await import('./EasClient-CVPHYGNP.js')).EasClient;
         }
         else if (isNode()) {
-            FileManager = (await import('./FileManager-CKyoLrBP.js')).FileManager;
-            Db = (await import('./Db-DkTBncAM.js')).Db;
-            QueryClient = (await import('./QueryClient-OUjfvY3g.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-DxpJnJXU.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-Ce4K9acQ.js')).PathResolver;
-            EasClient = (await import('./EasClient-JYkmHxu1.js')).EasClient;
+            FileManager = (await import('./FileManager-Ba5BCbCL.js')).FileManager;
+            Db = (await import('./Db-Cg7Q5gIc.js')).Db;
+            QueryClient = (await import('./QueryClient-BCxuWg7f.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-DoBABTLW.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-D7WqjJCo.js')).PathResolver;
+            EasClient = (await import('./EasClient-B4VivHxM.js')).EasClient;
         }
         else {
             throw new Error(`Unable to determine environment. isBrowser()=${isBrowser()}, isNode()=${isNode()}. Platform-specific implementations could not be loaded.`);
@@ -13865,11 +14980,14 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 dbConfig,
                 schemaFile,
                 schema,
-                syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? false,
+                syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? true,
             } });
         if (arweaveDomain) {
             setArweaveDomain(arweaveDomain);
         }
+        void ensureReadGatewaySelected().catch(() => {
+            /* non-blocking warm-up for read gateway probe */
+        });
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         setupAllItemsEventHandlers();
@@ -13905,15 +15023,15 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
     };
 });
 
-const logger$a = debug('seedSdk:client:writeToDb');
-const saveAppState$1 = fromCallback(({ sendBack, input: { key, value } }) => {
+const logger$9 = debug('seedSdk:client:writeToDb');
+const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
             const appDb = BaseDb.getAppDb();
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$a('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$9('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -13929,13 +15047,13 @@ const saveAppState$1 = fromCallback(({ sendBack, input: { key, value } }) => {
                     value: JSON.stringify(value),
                 },
             });
-            logger$a('result', result);
+            logger$9('result', result);
         }
         catch (error) {
-            logger$a('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$9('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$a('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$9('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -13950,10 +15068,10 @@ const saveAppState$1 = fromCallback(({ sendBack, input: { key, value } }) => {
         });
     })
         .catch((error) => {
-        logger$a('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$9('[client/actors] [saveAppState] Error in promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$a('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$9('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -13966,222 +15084,6 @@ const saveAppState$1 = fromCallback(({ sendBack, input: { key, value } }) => {
     });
 });
 
-const GET_FILES_METADATA = graphql(/* GraphQL */ `
-  query GetFilesMetadata($where: AttestationWhereInput!) {
-    filesMetadata: attestations(
-      where: $where
-      orderBy: [{ timeCreated: desc }]
-    ) {
-      ...attestationFields
-    }
-  }
-`);
-
-const getMetadata = async (props) => {
-    const appDb = BaseDb.getAppDb();
-    let storageTransactionId;
-    if (props) {
-        storageTransactionId = props.storageTransactionId;
-    }
-    const whereClauses = [];
-    if (storageTransactionId) {
-        whereClauses.push(eq(metadata$1.propertyName, 'storageTransactionId'));
-        whereClauses.push(eq(metadata$1.propertyValue, storageTransactionId));
-    }
-    const metadataRows = await appDb
-        .select()
-        .from(metadata$1)
-        .where(and(...whereClauses));
-    if (!metadataRows || metadataRows.length === 0) {
-        return;
-    }
-    return metadataRows[0];
-};
-
-const saveMetadata = async (metadataRecord, metadataValues) => {
-    if (!metadataRecord.localId) {
-        return;
-    }
-    const appDb = BaseDb.getAppDb();
-    await appDb
-        .update(metadata$1)
-        .set({
-        ...metadataValues,
-        updatedAt: Date.now(),
-    })
-        .where(eq(metadata$1.localId, metadataRecord.localId));
-};
-
-const saveAppState = async (key, value) => {
-    const appDb = BaseDb.getAppDb();
-    await appDb
-        .insert(appState)
-        .values({
-        key,
-        value,
-    })
-        .onConflictDoUpdate({
-        target: appState.key,
-        set: {
-            value,
-        },
-    });
-};
-
-const logger$9 = debug('seedSdk:files:download');
-// syncDbFiles helper - internal service removed, functionality moved here
-const syncDbFiles = async (endpoints) => {
-    // TODO: Implement syncDbFiles functionality if needed
-    // This was previously in @/services/internal/helpers
-    logger$9('[download] syncDbFiles called but not yet implemented');
-    return Promise.resolve();
-};
-const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
-    if (!isBrowser()) {
-        return;
-    }
-    await syncDbFiles();
-    eventEmitter.emit('fs.downloadAll.success', { eventId });
-    eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
-};
-const downloadAllFilesBinaryRequestHandler = async () => {
-    let addresses;
-    if (BaseDb.isAppDbReady()) {
-        addresses = await getAllAddressesFromDb();
-    }
-    if (!BaseDb.isAppDbReady()) {
-        // Wait for ClientManager to be ready (DB_INIT state or later)
-        const clientManagerMod = await Promise.resolve().then(function () { return ClientManager$1; });
-        const { getClient } = clientManagerMod;
-        const clientManager = getClient();
-        const clientService = clientManager.getService();
-        await waitFor(clientService, (snapshot) => {
-            const state = snapshot.value;
-            return state === 'dbInit' ||
-                state === 'saveConfig' ||
-                state === 'processSchemaFiles' ||
-                state === 'addModelsToStore' ||
-                state === 'addModelsToDb' ||
-                state === 'idle';
-        }, { timeout: 30000 });
-        addresses = await getAllAddressesFromDb();
-    }
-    if (!addresses || addresses.length === 0) {
-        return;
-    }
-    const queryClient = BaseQueryClient.getQueryClient();
-    const easClient = BaseEasClient.getEasClient();
-    const { filesMetadata } = await queryClient.fetchQuery({
-        queryKey: ['getFilesMetadata', ...addresses],
-        queryFn: async () => easClient.request(GET_FILES_METADATA, {
-            where: {
-                attester: {
-                    in: addresses,
-                },
-                schema: {
-                    is: {
-                        id: {
-                            equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
-                        },
-                    },
-                },
-            },
-        }),
-    });
-    const filesRoot = BaseFileManager.getWorkingDir();
-    await BaseFileManager.createDirIfNotExists(filesRoot);
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
-    const appDb = BaseDb.getAppDb();
-    if (!appDb) {
-        console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available');
-        return [];
-    }
-    const excludedTransactionsQuery = await appDb
-        .select()
-        .from(appState)
-        .where(eq(appState.key, 'excludedTransactions'));
-    let excludedTransactions = new Set();
-    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
-        const valueString = excludedTransactionsQuery[0].value;
-        if (valueString) {
-            const excludedTransactionsArray = JSON.parse(valueString);
-            excludedTransactions = new Set(excludedTransactionsArray);
-        }
-    }
-    const transactionIds = [];
-    for (const fileMetadata of filesMetadata) {
-        // Validate and parse decodedDataJson
-        if (!fileMetadata.decodedDataJson || fileMetadata.decodedDataJson.trim() === '') {
-            console.warn('[events/files] [download] empty decodedDataJson for fileMetadata: ', fileMetadata.id);
-            continue;
-        }
-        let json;
-        try {
-            json = JSON.parse(fileMetadata.decodedDataJson);
-        }
-        catch (error) {
-            console.warn('[events/files] [download] failed to parse decodedDataJson for fileMetadata: ', fileMetadata.id, error);
-            continue;
-        }
-        if (!Array.isArray(json) || json.length === 0 || !json[0]?.value?.value) {
-            console.warn('[events/files] [download] invalid decodedDataJson structure for fileMetadata: ', fileMetadata.id);
-            continue;
-        }
-        const transactionId = json[0].value.value;
-        if (excludedTransactions.has(transactionId)) {
-            continue;
-        }
-        transactionIds.push(transactionId);
-    }
-    const transactionIdsToDownload = [];
-    for (const transactionId of transactionIds) {
-        try {
-            // Use BaseArweaveClient for transaction status check
-            const status = await BaseArweaveClient.getTransactionStatus(transactionId);
-            if (status.status !== 200) {
-                logger$9(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
-                excludedTransactions.add(transactionId);
-                await saveAppState('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
-                continue;
-            }
-            // Use BaseArweaveClient for getting transaction tags
-            const tags = await queryClient.fetchQuery({
-                queryKey: ['getTransactionTags', transactionId],
-                queryFn: async () => BaseArweaveClient.getTransactionTags(transactionId),
-            });
-            if (tags && tags.length > 0) {
-                for (const { name, value } of tags) {
-                    if (name === 'Content-SHA-256') {
-                        const metadataRecord = await getMetadata({
-                            storageTransactionId: transactionId,
-                        });
-                        if (metadataRecord) {
-                            await saveMetadata(metadataRecord, {
-                                contentHash: value,
-                            });
-                        }
-                    }
-                }
-            }
-            transactionIdsToDownload.push(transactionId);
-        }
-        catch (error) {
-            logger$9(error);
-        }
-    }
-    await BaseFileManager.downloadAllFiles({
-        transactionIds: transactionIdsToDownload,
-        arweaveHost: BaseArweaveClient.getHost(),
-        excludedTransactions,
-    });
-    await BaseFileManager.resizeAllImages({
-        width: 480,
-        height: 480,
-    });
-};
-
 let isInitialized = false;
 const fsInitHandler = async () => {
     if (isInitialized) {
@@ -14347,7 +15249,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         }
         const schemaDefs = Array.from(schemaDefsByModelName.values()).map(({ schemaDef }) => schemaDef);
         // Fetch schemas from EAS in background - do not block init. EAS can be slow (10s+);
-        // modelUids will be populated async and syncDbWithEas will run when done.
+        // modelUids will be populated async and EAS sync orchestrator runs when done.
         const fetchEasAndPopulateModelUids = async () => {
             try {
                 const queryClient = BaseQueryClient.getQueryClient();
@@ -14380,7 +15282,8 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                             }
                         }
                     }
-                    eventEmitter.emit('syncDbWithEas');
+                    const { requestEasSyncFromModelsInit } = await Promise.resolve().then(function () { return easSyncManager; });
+                    requestEasSyncFromModelsInit();
                 }
                 else {
                     logger$6('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
@@ -16830,16 +17733,19 @@ function addressesFromPersistedAddressValue(value) {
     return out;
 }
 function maybeRunSyncFromEasAfterAddressSave({ context, event, }) {
+    const merged = addressesFromPersistedAddressValue(event.value);
     if (!context.syncFromEasOnAddressChange)
         return;
     if (event.key !== "addresses")
         return;
-    const merged = addressesFromPersistedAddressValue(event.value);
     if (merged.length === 0)
         return;
-    void runSyncFromEas({ addresses: merged }).catch((err) => {
-        logSyncAfterAddressSave("runSyncFromEas after address save failed", err);
-    });
+    try {
+        requestEasSyncFromAddressChange(merged);
+    }
+    catch (err) {
+        logSyncAfterAddressSave("requestEasSyncFromAddressChange after address save failed", err);
+    }
 }
 function emitAddressesPersistedIfAddressesKey(event) {
     if (event.key !== "addresses")
@@ -16857,7 +17763,7 @@ const clientManagerMachine = setup({
         fileSystemInit,
         dbInit,
         saveConfig,
-        saveAppState: saveAppState$1,
+        saveAppState,
         addModelsToStore,
         addModelsToDb,
         processSchemaFiles,
@@ -17181,7 +18087,16 @@ const clientInstance = {
      */
     syncFromEas: async (options) => {
         ensureInitialized();
-        await runSyncFromEas(options);
+        startEasSyncActor();
+        const correlationId = typeof globalThis.crypto?.randomUUID === 'function'
+            ? globalThis.crypto.randomUUID()
+            : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        sendEasSyncClientRequest(correlationId, options);
+        await waitFor(easSyncActor, (snapshot) => snapshot.context.lastFinishedCorrelationIds?.includes(correlationId) ?? false);
+        const snap = easSyncActor.getSnapshot();
+        if (snap.context.lastFinishedStatus === 'failed') {
+            throw new Error(snap.context.lastFinishedError ?? 'EAS sync failed');
+        }
     },
     addModel: async (modelDef) => {
         const db = await BaseDb.getAppDb();
@@ -17391,7 +18306,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-DWtv9fQr.js')
+const modelPropertyImportPromise = import('./ModelProperty-D6JLRqQW.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -17408,7 +18323,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_9 = await import('./Schema-CqqcEexA.js'); return _mod_9.b; })()
+const schemaImportPromise = (async () => { const _mod_10 = await import('./Schema-B5_B8nM5.js'); return _mod_10.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -19148,5 +20063,5 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
-export { getItemData as $, models$1 as A, Boolean$1 as B, properties as C, Date$1 as D, isValidEasAttestationUid as E, File$1 as F, getLatestPublishedVersionRow as G, Html as H, Image as I, Json as J, modelPropertiesToObject as K, List as L, Model as M, Number$1 as N, parseListPropertyValueFromStorage as O, Property as P, getCorrectId as Q, Relation as R, INTERNAL_PROPERTY_NAMES as S, TModelValues as T, defaultAttestationData as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, INTERNAL_DATA_TYPES as W, toSnakeCase as X, getEasSchemaUidForSchemaDefinition as Y, ZERO_BYTES32 as Z, getEasSchemaForItemProperty as _, TModelSchema as a, setSchemaUidForModel as a$, resolveStorageNameToSchemaName as a0, appState as a1, BasePathResolver as a2, SEED_CONFIG_FILE as a3, SEED_CONFIG_FALLBACKS as a4, BaseEasClient as a5, EAS_ENDPOINT as a6, BaseQueryClient as a7, arweaveL1FinalizeJobs as a8, config as a9, syncSchemaFromSource as aA, transformImportToSchemaFile as aB, writeProcessMachine as aC, getModelIdByFileId as aD, generateId as aE, waitForEntityIdle as aF, createReactiveProxy as aG, findEntity as aH, forceRemoveFromCaches as aI, runDestroyLifecycle as aJ, getModelId as aK, isPlaceholderUid as aL, normalizeBytes32Hex as aM, getArweaveUrlForTransaction as aN, ADDRESSES_PERSISTED_EVENT as aO, parseAddressesPersistedPayload as aP, getClient as aQ, ClientManagerState as aR, MachineIds as aS, createNewItem as aT, getVersionData$1 as aU, getMetadataLatest as aV, loadAllSchemasFromDb as aW, propertyMachine as aX, SEED_PROTOCOL_SCHEMA_NAME as aY, ImageSize as aZ, setSchemaUidForSchemaDefinition as a_, metadata$1 as aa, modelRelations as ab, modelSchemas as ac, modelUids as ad, modelsRelations as ae, propertiesRelations as af, propertyUidRelations as ag, propertyUids as ah, publishProcesses as ai, schemas as aj, uploadProcesses as ak, versions as al, graphql as am, getPropertyIdForModelAndName as an, saveAppState as ao, addModelsToDb$1 as ap, SCHEMA_NJK as aq, ItemProperty as ar, eventEmitter as as, ClientManager as at, INIT_SCRIPT_SUCCESS_MESSAGE as au, SCHEMA_TS as av, getRefValueType as aw, importJsonSchema as ax, loadSchemaFromFile as ay, readJsonImportFile as az, ModelPropertyDataTypes as b, getModelSchemasFromEas as b0, getItemVersionsFromEas as b1, getItemPropertiesFromEas as b2, getCanonicalItemPropertiesFromEas as b3, getEasSchemaUidBySchemaName as b4, getSeedsFromSchemaUids as b5, getSeedsBySchemaName as b6, withExcludeRevokedFilter as b7, classifyMediaRef as b8, resolveMediaRef as b9, getSchemaNameFromId as bA, addSchemaToDb as bB, createModelsFromJson as bC, loadModelsFromDbForSchema as bD, getLatestSchemaVersion as bE, isInternalSchema as bF, createModelFromJson as bG, ConflictError as bH, unloadEntity as bI, clearDestroySubscriptions as bJ, setupEntityLiveQuery as bK, ModelSchema as bL, BaseFileManager$1 as bM, db as bN, eas as bO, getPropertyData$1 as bP, schema as bQ, SEEDPROTOCOL_Seed_Protocol_v1 as bR, Model$1 as bS, normalizeFeedItemFields as ba, getFeedItemStringField as bb, pickLatestPropertyAttestationsByRefAndSchema as bc, SeedModels as bd, DEFAULT_ARWEAVE_HOST as be, DEFAULT_ARWEAVE_GATEWAYS as bf, DEFAULT_ARWEAVE_GRAPHQL_URL as bg, updateSeedRevokedAt as bh, getAddressesForItemsFilter as bi, normalizeUploadApiBaseUrl as bj, getUploadApiArweaveDataUrl as bk, getUploadPipelineTransactionStatus as bl, getUploadApiArweaveStatusUrl as bm, getArweaveUploadStatus as bn, isArweaveL1AnchoringComplete as bo, queryArweaveGatewayTransaction as bp, setUploadExecutor as bq, getUploadExecutor as br, setGetPublisherForNewSeeds as bs, getGetPublisherForNewSeeds as bt, setRevokeExecutor as bu, getRevokeExecutor as bv, setAdditionalSyncAddresses as bw, createSchema as bx, readSchema as by, listCompleteSchemaFiles as bz, TPropertyDataType as c, TStorageType as d, THtmlEmbeddedDataUriPolicy as e, TProperty as f, TPropertyConstructor as g, TPropertyDefs as h, PropertyMetadataKey as i, PropertyConstructor as j, Text as k, DEFAULT_TEXT_MAX_LENGTH as l, TValidationRules as m, normalizeDataType as n, getOwnedAddressesFromDb as o, BaseDb as p, getGetAdditionalSyncAddresses as q, resolveSeedIdsFromRefString as r, seeds as s, normalizeRelationPropertyValue as t, Item as u, BaseFileManager as v, getContentHash as w, htmlEmbeddedImageCoPublish as x, BaseArweaveClient as y, getEasSchemaUidForModel as z };
-//# sourceMappingURL=index-BrD_NNaX.js.map
+export { getItemData as $, models$1 as A, Boolean$1 as B, properties as C, Date$1 as D, isValidEasAttestationUid as E, File$1 as F, getLatestPublishedVersionRow as G, Html as H, Image as I, Json as J, modelPropertiesToObject as K, List as L, Model as M, Number$1 as N, parseListPropertyValueFromStorage as O, Property as P, getCorrectId as Q, Relation as R, INTERNAL_PROPERTY_NAMES as S, TModelValues as T, defaultAttestationData as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, INTERNAL_DATA_TYPES as W, toSnakeCase as X, getEasSchemaUidForSchemaDefinition as Y, ZERO_BYTES32 as Z, getEasSchemaForItemProperty as _, TModelSchema as a, compareMetadataRowsLatestFirst as a$, resolveStorageNameToSchemaName as a0, appState as a1, BasePathResolver as a2, SEED_CONFIG_FILE as a3, SEED_CONFIG_FALLBACKS as a4, BaseEasClient as a5, EAS_ENDPOINT as a6, BaseQueryClient as a7, arweaveL1FinalizeJobs as a8, config as a9, GET_SEEDS as aA, GET_VERSIONS as aB, GET_PROPERTIES as aC, setSchemaUidForSchemaDefinition as aD, parseEasRelationPropertyName as aE, addModelsToDb$1 as aF, SCHEMA_NJK as aG, ItemProperty as aH, ClientManager as aI, INIT_SCRIPT_SUCCESS_MESSAGE as aJ, SCHEMA_TS as aK, getRefValueType as aL, importJsonSchema as aM, loadSchemaFromFile as aN, readJsonImportFile as aO, syncSchemaFromSource as aP, transformImportToSchemaFile as aQ, writeProcessMachine as aR, getModelIdByFileId as aS, waitForEntityIdle as aT, createReactiveProxy as aU, findEntity as aV, forceRemoveFromCaches as aW, runDestroyLifecycle as aX, getModelId as aY, isPlaceholderUid as aZ, normalizeBytes32Hex as a_, easSyncProcesses as aa, metadata$1 as ab, modelRelations as ac, modelSchemas as ad, modelUids as ae, modelsRelations as af, propertiesRelations as ag, propertyUidRelations as ah, propertyUids as ai, publishProcesses as aj, schemas as ak, uploadProcesses as al, versions as am, graphql as an, getPropertyIdForModelAndName as ao, getAllAddressesFromDb as ap, getModelSchemasFromEas as aq, getSeedsFromSchemaUids as ar, getItemVersionsFromEas as as, getItemPropertiesFromEas as at, pickLatestPropertyAttestationsByRefAndSchema as au, scheduleBulkFilesDownloadFromEasSync as av, eventEmitter as aw, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as ax, generateId as ay, escapeSqliteString as az, ModelPropertyDataTypes as b, isInternalSchema as b$, getArweaveUrlForTransaction as b0, ADDRESSES_PERSISTED_EVENT as b1, parseAddressesPersistedPayload as b2, getClient as b3, ClientManagerState as b4, MachineIds as b5, createNewItem as b6, getVersionData$1 as b7, getMetadataLatest as b8, loadAllSchemasFromDb as b9, queryArweaveGatewayTransaction as bA, queryArweaveGatewayTransactionWithFallback as bB, ensureReadGatewaySelected as bC, invalidateReadGatewayCache as bD, resetArweaveReadGatewayForTests as bE, setUploadExecutor as bF, getUploadExecutor as bG, setGetPublisherForNewSeeds as bH, getGetPublisherForNewSeeds as bI, setRevokeExecutor as bJ, getRevokeExecutor as bK, setAdditionalSyncAddresses as bL, createSchema as bM, readSchema as bN, listCompleteSchemaFiles as bO, getSchemaNameFromId as bP, easSyncActor as bQ, startEasSyncActor as bR, sendEasSyncClientRequest as bS, requestEasSyncFromAddressChange as bT, requestEasSyncFromEventBus as bU, requestEasSyncFromModelsInit as bV, mergeEasSyncRequestIntents as bW, addSchemaToDb as bX, createModelsFromJson as bY, loadModelsFromDbForSchema as bZ, getLatestSchemaVersion as b_, propertyMachine as ba, SEED_PROTOCOL_SCHEMA_NAME as bb, ImageSize as bc, setSchemaUidForModel as bd, getCanonicalItemPropertiesFromEas as be, getEasSchemaUidBySchemaName as bf, getSeedsBySchemaName as bg, withExcludeRevokedFilter as bh, classifyMediaRef as bi, resolveMediaRef as bj, normalizeFeedItemFields as bk, getFeedItemStringField as bl, SeedModels as bm, DEFAULT_ARWEAVE_HOST as bn, DEFAULT_ARWEAVE_GATEWAYS as bo, DEFAULT_ARWEAVE_GRAPHQL_URL as bp, getDefaultArweaveReadGatewayHostsOrdered as bq, mergePrimaryHostWithDefaults as br, isKnownArweaveGatewayHostname as bs, getAddressesForItemsFilter as bt, normalizeUploadApiBaseUrl as bu, getUploadApiArweaveDataUrl as bv, getUploadPipelineTransactionStatus as bw, getUploadApiArweaveStatusUrl as bx, getArweaveUploadStatus as by, isArweaveL1AnchoringComplete as bz, TPropertyDataType as c, createModelFromJson as c0, ConflictError as c1, unloadEntity as c2, clearDestroySubscriptions as c3, setupEntityLiveQuery as c4, ModelSchema as c5, BaseFileManager$1 as c6, db as c7, eas as c8, getPropertyData$1 as c9, Item$1 as ca, schema as cb, SEEDPROTOCOL_Seed_Protocol_v1 as cc, Model$1 as cd, TStorageType as d, THtmlEmbeddedDataUriPolicy as e, TProperty as f, TPropertyConstructor as g, TPropertyDefs as h, PropertyMetadataKey as i, PropertyConstructor as j, Text as k, DEFAULT_TEXT_MAX_LENGTH as l, TValidationRules as m, normalizeDataType as n, getOwnedAddressesFromDb as o, BaseDb as p, getGetAdditionalSyncAddresses as q, resolveSeedIdsFromRefString as r, seeds as s, normalizeRelationPropertyValue as t, Item as u, BaseFileManager as v, getContentHash as w, htmlEmbeddedImageCoPublish as x, BaseArweaveClient as y, getEasSchemaUidForModel as z };
+//# sourceMappingURL=index-18lln0cM.js.map