@seedprotocol/sdk 0.4.21 → 0.4.22

package/dist/cjs/{index-D1qR8xnb.js → index-C6rrqy3z.js}

@@ -198,6 +198,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 });
     }
@@ -406,8 +413,51 @@ 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 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;
+}
+/** 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
  */
@@ -419,7 +469,9 @@ function isInternalSchema(schemaName, schemaId) {
 var constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
     CLIENT_NOT_INITIALIZED: CLIENT_NOT_INITIALIZED,
+    DEFAULT_ARWEAVE_GATEWAYS: DEFAULT_ARWEAVE_GATEWAYS,
     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,
@@ -437,7 +489,9 @@ var constants = /*#__PURE__*/Object.freeze({
     ZERO_BYTES: ZERO_BYTES,
     ZERO_BYTES32: ZERO_BYTES32,
     defaultAttestationData: defaultAttestationData,
-    isInternalSchema: isInternalSchema
+    getDefaultArweaveReadGatewayHostsOrdered: getDefaultArweaveReadGatewayHostsOrdered,
+    isInternalSchema: isInternalSchema,
+    mergePrimaryHostWithDefaults: mergePrimaryHostWithDefaults
 });
 
 function parseGateway(input) {
@@ -454,6 +508,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;
@@ -466,7 +522,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);
             }
         }
@@ -504,6 +560,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
@@ -587,6 +676,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.
  */
@@ -638,6 +732,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) {
@@ -734,6 +948,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) {
@@ -1409,6 +1659,19 @@ const arweaveL1FinalizeJobs = sqliteCore.sqliteTable('arweave_l1_finalize_jobs',
     dataItemIdUnique: sqliteCore.uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
 }));
 
+const easSyncProcesses = sqliteCore.sqliteTable('eas_sync_processes', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    status: sqliteCore.text('status').notNull(), // 'in_progress' | 'completed' | 'failed'
+    startedAt: sqliteCore.int('started_at').notNull(),
+    completedAt: sqliteCore.int('completed_at'),
+    requestPayload: sqliteCore.text('request_payload').notNull(),
+    errorMessage: sqliteCore.text('error_message'),
+    errorDetails: sqliteCore.text('error_details'),
+    persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.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).
@@ -1430,6 +1693,7 @@ var schema$1 = /*#__PURE__*/Object.freeze({
     appState: appState,
     arweaveL1FinalizeJobs: arweaveL1FinalizeJobs,
     config: config,
+    easSyncProcesses: easSyncProcesses,
     htmlEmbeddedImageCoPublish: htmlEmbeddedImageCoPublish,
     metadata: metadata$1,
     modelRelations: modelRelations,
@@ -1922,6 +2186,7 @@ var index = /*#__PURE__*/Object.freeze({
     capitalizeFirstLetter: capitalizeFirstLetter,
     classifyMediaRef: classifyMediaRef,
     convertTxIdToImage: convertTxIdToImage,
+    ensureReadGatewaySelected: ensureReadGatewaySelected,
     generateId: generateId,
     getAlternatePropertyNameForInstanceLookup: getAlternatePropertyNameForInstanceLookup,
     getArweaveUploadStatus: getArweaveUploadStatus,
@@ -1941,6 +2206,7 @@ var index = /*#__PURE__*/Object.freeze({
     getUploadExecutor: getUploadExecutor,
     getUploadPipelineTransactionStatus: getUploadPipelineTransactionStatus,
     identifyString: identifyString,
+    invalidateReadGatewayCache: invalidateReadGatewayCache,
     isArweaveL1AnchoringComplete: isArweaveL1AnchoringComplete,
     isBinary: isBinary,
     isPlaceholderUid: isPlaceholderUid,
@@ -1953,11 +2219,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,
@@ -1980,7 +2250,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-tfM38NL4.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$y('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -2164,7 +2434,7 @@ const loadOrCreateModel = xstate.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 schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -2408,7 +2678,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -2452,10 +2722,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -2565,7 +2835,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$w(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-tfM38NL4.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$w('ModelProperty not available from dynamic import');
@@ -2669,7 +2939,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$v(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -2687,7 +2957,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$v(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -2723,7 +2993,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -2738,7 +3008,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -2767,7 +3037,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -4719,7 +4989,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-tfM38NL4.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -5099,7 +5369,7 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-tfM38NL4.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5402,6 +5672,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";
@@ -5474,7 +5745,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 = xstate.fromCallback(({ sendBack }) => {
@@ -6357,7 +6628,7 @@ const getMetadataLatest = ({ seedLocalId, seedUid }) => {
         rowNum: drizzleOrm.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')
     })
@@ -6370,6 +6641,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$q = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
@@ -6411,9 +6701,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();
@@ -6461,7 +6750,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -6510,7 +6799,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -6557,7 +6846,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 Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6814,9 +7103,9 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdVy-5fK.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-BljRx4o4.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DP2fm4q8.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-ddl-1x6R.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -7162,6 +7451,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.
@@ -7651,7 +7945,7 @@ const resolveRelatedValue = xstate.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 Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -8014,174 +8308,814 @@ 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$l = debug('seedSdk:property:actors:hydrateFromDb');
-const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) => {
-    const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
-    if (!propertyNameRaw) {
-        throw new Error('propertyName is required');
+const eventEmitter = new EventEmitter();
+
+const GET_FILES_METADATA = graphql(/* GraphQL */ `
+  query GetFilesMetadata($where: AttestationWhereInput!) {
+    filesMetadata: attestations(
+      where: $where
+      orderBy: [{ timeCreated: desc }]
+    ) {
+      ...attestationFields
     }
-    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 Promise.resolve().then(function () { return require('./index-DTkoTvcq.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
-            ? drizzleOrm.or(...propertyNames.map((n) => drizzleOrm.eq(metadata$1.propertyName, n)))
-            : drizzleOrm.eq(metadata$1.propertyName, propertyNames[0]));
-        if (seedUid) {
-            whereClauses.push(drizzleOrm.eq(metadata$1.seedUid, seedUid));
-        }
-        if (seedLocalId) {
-            whereClauses.push(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId));
-        }
-        const rows = await appDb
-            .select()
-            .from(metadata$1)
-            .where(drizzleOrm.and(...whereClauses))
-            .orderBy(drizzleOrm.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedUid, propertyValueFromDb), drizzleOrm.or(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'), drizzleOrm.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$l('[hydrateFromDb] Image 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: 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;
-                }
-                const renderValue = await BaseFileManager.readFileAsString(filePath);
-                const property = item.properties.find(p => p.propertyName === propertyName);
+  }
+`);
+
+const getMetadata = async (props) => {
+    const appDb = BaseDb.getAppDb();
+    let storageTransactionId;
+    if (props) {
+        storageTransactionId = props.storageTransactionId;
+    }
+    const whereClauses = [];
+    if (storageTransactionId) {
+        whereClauses.push(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'));
+        whereClauses.push(drizzleOrm.eq(metadata$1.propertyValue, storageTransactionId));
+    }
+    const metadataRows = await appDb
+        .select()
+        .from(metadata$1)
+        .where(drizzleOrm.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(drizzleOrm.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$l = 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$l('[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 xstate.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(drizzleOrm.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 = drizzleOrm.or(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'), drizzleOrm.eq(metadata$1.propertyName, 'storage_transaction_id'), drizzleOrm.eq(metadata$1.propertyName, 'transactionId'));
+    const propRows = await appDb
+        .select({ propertyValue: metadata$1.propertyValue })
+        .from(metadata$1)
+        .where(drizzleOrm.and(nameOr, drizzleOrm.isNotNull(metadata$1.propertyValue)));
+    const refRows = await appDb
+        .select({ refResolvedValue: metadata$1.refResolvedValue })
+        .from(metadata$1)
+        .where(drizzleOrm.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$l(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 = lodashEs.throttle((addressesHint) => {
+    void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
+        logger$l('[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$k = debug('seedSdk:property:actors:hydrateFromDb');
+const hydrateFromDb = xstate.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 Promise.resolve().then(function () { return require('./index-DqSDhOp3.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
+            ? drizzleOrm.or(...propertyNames.map((n) => drizzleOrm.eq(metadata$1.propertyName, n)))
+            : drizzleOrm.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(drizzleOrm.or(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId), drizzleOrm.eq(metadata$1.seedUid, seedUid)));
+        }
+        else if (seedUid) {
+            whereClauses.push(drizzleOrm.eq(metadata$1.seedUid, seedUid));
+        }
+        else if (seedLocalId) {
+            whereClauses.push(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId));
+        }
+        const rows = await appDb
+            .select()
+            .from(metadata$1)
+            .where(drizzleOrm.and(...whereClauses))
+            .orderBy(drizzleOrm.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedUid, propertyValueFromDb), drizzleOrm.or(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'), drizzleOrm.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$k('[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$k('[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);
+                const property = item.properties.find(p => p.propertyName === propertyName);
                 if (property) {
                     property.getService().send({ type: 'updateContext', renderValue });
                 }
                 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,
@@ -8193,8 +9127,8 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                     versionUid: versionUidFromDb,
                     schemaUid: schemaUidFromDb,
                     refValueType,
-                    localStorageDir: htmlLocalStorageDir,
-                    refResolvedValue,
+                    localStorageDir: outDir,
+                    refResolvedValue: outRef ?? refResolvedValue,
                     refResolvedDisplayValue,
                     renderValue: htmlContent,
                     populatedFromDb: true,
@@ -8208,11 +9142,11 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-const logger$k = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$j = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$k(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$j(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -8258,15 +9192,15 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         const schemas = modelPropertiesToObject(model$1.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$k(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$j(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$k(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$j(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$k(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$j(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -8332,7 +9266,7 @@ const loadOrCreateProperty = xstate.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 Promise.resolve().then(function () { return require('./property-BQokoaRe.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-2D7P6a2q.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8370,7 +9304,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (error) {
-                logger$k(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$j(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
@@ -8388,22 +9322,27 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                     const schemas = modelPropertiesToObject(model$1.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$k(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$j(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$k(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$j(`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 === exports.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) {
@@ -8413,13 +9352,34 @@ const loadOrCreateProperty = xstate.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$k(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$j(`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)
@@ -8429,28 +9389,83 @@ const loadOrCreateProperty = xstate.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedUid, metadataRecord.propertyValue), drizzleOrm.or(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'), drizzleOrm.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$j(`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$j(`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$k(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$j(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -8482,7 +9497,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$k(`Error in loadOrCreateProperty: ${error}`);
+        logger$j(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -8512,10 +9527,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$j = debug('seedSdk:write:updateItemPropertyValue');
+const logger$i = 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$j(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$i(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -8543,7 +9558,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
                 .select()
                 .from(metadata$1)
                 .where(drizzleOrm.and(propertyNameWhere, drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId)))
-                .orderBy(drizzleOrm.sql.raw('COALESCE(attestation_created_at, created_at) DESC')));
+                .orderBy(drizzleOrm.sql.raw('COALESCE(attestation_created_at, created_at) DESC, local_id DESC')));
         }
     }
     else if (localIdParam) {
@@ -8563,7 +9578,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             .select()
             .from(metadata$1)
             .where(drizzleOrm.and(propertyNameWhere, drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId)))
-            .orderBy(drizzleOrm.sql.raw('COALESCE(attestation_created_at, created_at) DESC')));
+            .orderBy(drizzleOrm.sql.raw('COALESCE(attestation_created_at, created_at) DESC, local_id DESC')));
     }
     // const mostRecentRecordStatement = `SELECT local_id,
     //                                           uid,
@@ -8579,7 +9594,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) {
@@ -8588,7 +9603,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$j(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$i(`[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
@@ -8716,9 +9731,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8916,7 +9931,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-Cq_YBzFN.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, propertyRecordSchema.dataType, propertyRecordSchema.validation, propertyRecordSchema.refValueType);
         if (!validationResult.isValid && validationResult.errors.length > 0) {
@@ -8994,8 +10009,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();
@@ -9142,6 +10155,12 @@ const saveImage = xstate.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,
@@ -9151,7 +10170,7 @@ const saveImage = xstate.fromCallback(({ sendBack, input: { context, event } })
                 versionLocalId,
                 versionUid,
                 modelName,
-                schemaUid: imageSchemaUid,
+                schemaUid: resolvedPropertySchemaUid,
                 refSeedType: 'image',
                 refModelUid: imageSchemaUid,
                 refResolvedValue: fileName,
@@ -9170,7 +10189,7 @@ const saveImage = xstate.fromCallback(({ sendBack, input: { context, event } })
                 seedLocalId,
                 versionLocalId,
                 modelName,
-                schemaUid,
+                schemaUid: resolvedPropertySchemaUid,
                 refSeedType: 'image',
                 refResolvedValue: fileName,
                 localStorageDir: '/images',
@@ -9503,7 +10522,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9712,6 +10731,10 @@ const propertyMachine = xstate.setup({
         context: {},
         input: {},
     },
+    guards: {
+        // stateIn return type does not satisfy setup() inference; runtime guard is correct for root state `idle`.
+        propertyMachineIsIdle: xstate.stateIn('idle'),
+    },
     // actions: {
     //   updateContext: updateMachineContext,
     // },
@@ -9734,7 +10757,11 @@ const propertyMachine = xstate.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: xstate.assign({
                 isSaving: true,
@@ -10333,6 +11360,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;
@@ -10432,7 +11461,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 ? lodashEs.upperFirst(lodashEs.camelCase(modelType)) : '';
-const logger$i = debug('seedSdk:property:class');
+const logger$h = 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 = [
@@ -10514,7 +11543,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$i('List property value is not JSON', e);
+                        logger$h('List property value is not JSON', e);
                     }
                 }
             }
@@ -10537,7 +11566,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DqSDhOp3.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -10560,7 +11589,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)
@@ -10596,7 +11626,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);
                     }
@@ -10616,8 +11650,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 {
@@ -10626,13 +11660,21 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$i(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
-                    renderValue = 'No file found';
+                    logger$h(`[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')) {
@@ -11045,6 +12087,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 === exports.ModelPropertyDataTypes.Html;
+                const isListProp = dt === exports.ModelPropertyDataTypes.List;
+                const isRelationProp = dt === exports.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;
@@ -11394,7 +12465,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-CXlKAj4o.js'); });
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -11733,7 +12804,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-CXlKAj4o.js'); });
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -11757,7 +12828,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-CXlKAj4o.js'); });
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11793,12 +12864,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdVy-5fK.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-BljRx4o4.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DP2fm4q8.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-ddl-1x6R.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -11915,6 +12986,8 @@ class Item {
             'schemaUid',
             'latestVersionLocalId',
             'latestVersionUid',
+            'publishedVersionUid',
+            'publishedVersionLocalId',
         ];
         const keysFromInitial = Object.keys(initialValues).filter((key) => !metadataKeys.includes(key));
         const schemaNameForModel = initialValues.schemaName;
@@ -11958,6 +13031,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 xstate.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;
@@ -11965,45 +13160,66 @@ class Item {
             props.modelName = lodashEs.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;
@@ -12092,14 +13308,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 {
@@ -12275,14 +13488,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 {
@@ -12305,14 +13515,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;
     }
@@ -12358,8 +13564,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;
         }
@@ -12390,10 +13596,127 @@ 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 lodashEs.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 { metadata } = await Promise.resolve().then(function () { return schema$1; });
+        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 (xstate.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;
@@ -13008,15 +14331,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) => {
@@ -13045,11 +14363,10 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-CXlKAj4o.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(),
@@ -13106,600 +14423,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, drizzleOrm.eq(models$1.id, modelUids.modelId))
-            .where(drizzleOrm.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(drizzleOrm.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(drizzleOrm.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(drizzleOrm.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(drizzleOrm.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(drizzleOrm.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 = xstate.fromPromise(async ({ input, }) => {
+    const rowId = await insertEasSyncProcessRow({
+        requestPayload: input.requestPayload,
+        persistedSnapshot: input.runningSnapshot,
+    });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DcKL-_Pb.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;
-    lodashEs.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.propertyName, _propertyName), drizzleOrm.eq(metadata$1.propertyValue, propertyValue), drizzleOrm.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(drizzleOrm.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 = lodashEs.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 = lodashEs.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(drizzleOrm.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 = xstate.setup({
+    types: {
+        context: {},
+        events: {},
+    },
+    actors: {
+        runEasSync,
+    },
+}).createMachine({
+    id: MachineIds.EAS_SYNC_MANAGER,
+    initial: 'idle',
+    context: initialContext,
+    states: {
+        idle: {
+            on: {
+                REQUEST: {
+                    target: 'running',
+                    actions: xstate.assign({
+                        runOptions: ({ event }) => event.options === undefined
+                            ? {}
+                            : mergeEasSyncRequestIntents([event.options]),
+                        activeCorrelationIds: ({ event }) => [event.correlationId],
+                        activePrimarySource: ({ event }) => event.source,
+                    }),
+                },
+            },
+        },
+        running: {
+            on: {
+                REQUEST: {
+                    actions: xstate.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: xstate.assign({
+                        lastFinishedCorrelationIds: ({ context }) => [
+                            ...context.activeCorrelationIds,
+                        ],
+                        lastFinishedStatus: () => 'success',
+                        lastFinishedError: () => null,
+                        activeCorrelationIds: () => [],
+                        runOptions: () => ({}),
+                    }),
+                },
+                onError: {
+                    target: 'afterRun',
+                    actions: [
+                        xstate.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: xstate.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 = xstate.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 = lodashEs.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$h = debug('seedSdk:services:events');
+const logger$g = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$h(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$g(`[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))
 };
@@ -13708,7 +14756,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
 
@@ -13742,9 +14791,9 @@ class BasePathResolver {
     }
 }
 
-const logger$g = debug('seedSdk:ClientManager:initialize');
+const logger$f = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$g('initialize from ClientManager');
+    logger$f('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -13867,11 +14916,14 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
                 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();
@@ -13907,15 +14959,15 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
     };
 });
 
-const logger$f = debug('seedSdk:client:writeToDb');
-const saveAppState$1 = xstate.fromCallback(({ sendBack, input: { key, value } }) => {
+const logger$e = debug('seedSdk:client:writeToDb');
+const saveAppState = xstate.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$f('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$e('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -13931,13 +14983,13 @@ const saveAppState$1 = xstate.fromCallback(({ sendBack, input: { key, value } })
                     value: JSON.stringify(value),
                 },
             });
-            logger$f('result', result);
+            logger$e('result', result);
         }
         catch (error) {
-            logger$f('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$e('[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$f('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$e('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -13952,10 +15004,10 @@ const saveAppState$1 = xstate.fromCallback(({ sendBack, input: { key, value } })
         });
     })
         .catch((error) => {
-        logger$f('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$e('[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$f('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$e('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -13968,222 +15020,6 @@ const saveAppState$1 = xstate.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(drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'));
-        whereClauses.push(drizzleOrm.eq(metadata$1.propertyValue, storageTransactionId));
-    }
-    const metadataRows = await appDb
-        .select()
-        .from(metadata$1)
-        .where(drizzleOrm.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(drizzleOrm.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$e = 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$e('[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 xstate.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(drizzleOrm.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$e(`[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$e(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) {
@@ -14349,7 +15185,7 @@ const addModelsToDb = xstate.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();
@@ -14382,7 +15218,8 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                             }
                         }
                     }
-                    eventEmitter.emit('syncDbWithEas');
+                    const { requestEasSyncFromModelsInit } = await Promise.resolve().then(function () { return easSyncManager; });
+                    requestEasSyncFromModelsInit();
                 }
                 else {
                     logger$b('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
@@ -16724,16 +17561,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")
@@ -16751,7 +17591,7 @@ const clientManagerMachine = xstate.setup({
         fileSystemInit,
         dbInit,
         saveConfig,
-        saveAppState: saveAppState$1,
+        saveAppState,
         addModelsToStore,
         addModelsToDb,
         processSchemaFiles,
@@ -17075,7 +17915,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 xstate.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();
@@ -17285,7 +18134,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 = Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-tfM38NL4.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -17302,7 +18151,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-44NqLqMV.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -19256,7 +20105,7 @@ class Db extends BaseDb {
         // You can inspect what will happen before applying
         await apply();
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-DhAXAuSf.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-D1nLJAhB.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -19903,7 +20752,7 @@ const getTsImport = async (filePath) => {
 
 // Get the directory of this file to resolve relative paths
 // @ts-ignore - rollup plugin-typescript doesn't recognize import.meta with module: "preserve"
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-D1qR8xnb.js', document.baseURI).href)));
+const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-C6rrqy3z.js', document.baseURI).href)));
 path.dirname(__filename$1);
 const commandExists = (command) => {
     try {
@@ -20151,6 +21000,7 @@ QueryClient.getQueryClient = () => {
                 reject(new Error('Not implemented'));
             });
         },
+        removeQueries: async () => { },
     };
 };
 BaseQueryClient.setPlatformClass(QueryClient);
@@ -20365,23 +21215,30 @@ immer.enableMapSet();
 
 exports.BaseArweaveClient = BaseArweaveClient;
 exports.BaseDb = BaseDb;
+exports.BaseEasClient = BaseEasClient;
 exports.BaseFileManager = BaseFileManager;
 exports.BaseFileManager$1 = BaseFileManager$1;
 exports.BasePathResolver = BasePathResolver;
+exports.BaseQueryClient = BaseQueryClient;
 exports.Boolean = Boolean$1;
 exports.ClientManager = ClientManager;
 exports.ConflictError = ConflictError;
 exports.DEFAULT_TEXT_MAX_LENGTH = DEFAULT_TEXT_MAX_LENGTH;
 exports.Date = Date$1;
 exports.Db = Db;
+exports.EAS_SEED_DATA_SYNCED_TO_DB_EVENT = EAS_SEED_DATA_SYNCED_TO_DB_EVENT;
 exports.File = File$1;
 exports.FileManager = FileManager;
+exports.GET_PROPERTIES = GET_PROPERTIES;
+exports.GET_SEEDS = GET_SEEDS;
+exports.GET_VERSIONS = GET_VERSIONS;
 exports.Html = Html;
 exports.INIT_SCRIPT_SUCCESS_MESSAGE = INIT_SCRIPT_SUCCESS_MESSAGE;
 exports.INTERNAL_DATA_TYPES = INTERNAL_DATA_TYPES;
 exports.INTERNAL_PROPERTY_NAMES = INTERNAL_PROPERTY_NAMES;
 exports.Image = Image;
 exports.Item = Item;
+exports.Item$1 = Item$1;
 exports.ItemProperty = ItemProperty;
 exports.Json = Json;
 exports.List = List;
@@ -20422,12 +21279,14 @@ exports.createReactiveProxy = createReactiveProxy;
 exports.db = db;
 exports.defaultAttestationData = defaultAttestationData;
 exports.eas = eas;
+exports.escapeSqliteString = escapeSqliteString;
 exports.eventEmitter = eventEmitter;
 exports.findEntity = findEntity;
 exports.findSeedBinary = findSeedBinary;
 exports.forceRemoveFromCaches = forceRemoveFromCaches;
 exports.generateId = generateId;
 exports.generateModelCode = generateModelCode;
+exports.getAllAddressesFromDb = getAllAddressesFromDb;
 exports.getClient = getClient;
 exports.getContentHash = getContentHash;
 exports.getCorrectId = getCorrectId;
@@ -20436,14 +21295,18 @@ exports.getEasSchemaUidForModel = getEasSchemaUidForModel;
 exports.getEasSchemaUidForSchemaDefinition = getEasSchemaUidForSchemaDefinition;
 exports.getGetAdditionalSyncAddresses = getGetAdditionalSyncAddresses;
 exports.getItemData = getItemData;
+exports.getItemPropertiesFromEas = getItemPropertiesFromEas;
+exports.getItemVersionsFromEas = getItemVersionsFromEas;
 exports.getLatestPublishedVersionRow = getLatestPublishedVersionRow;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
 exports.getModelIdByFileId = getModelIdByFileId;
+exports.getModelSchemasFromEas = getModelSchemasFromEas;
 exports.getOwnedAddressesFromDb = getOwnedAddressesFromDb;
 exports.getPropertyData = getPropertyData$1;
 exports.getPropertyIdForModelAndName = getPropertyIdForModelAndName;
 exports.getRefValueType = getRefValueType;
+exports.getSeedsFromSchemaUids = getSeedsFromSchemaUids;
 exports.getTsImport = getTsImport;
 exports.htmlEmbeddedImageCoPublish = htmlEmbeddedImageCoPublish;
 exports.importJsonSchema = importJsonSchema;
@@ -20460,8 +21323,10 @@ exports.modelUids = modelUids;
 exports.models = models$1;
 exports.normalizeDataType = normalizeDataType;
 exports.normalizeRelationPropertyValue = normalizeRelationPropertyValue;
+exports.parseEasRelationPropertyName = parseEasRelationPropertyName;
 exports.parseListPropertyValueFromStorage = parseListPropertyValueFromStorage;
 exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter;
+exports.pickLatestPropertyAttestationsByRefAndSchema = pickLatestPropertyAttestationsByRefAndSchema;
 exports.processSeedConfig = processSeedConfig;
 exports.properties = properties;
 exports.readJsonImportFile = readJsonImportFile;
@@ -20470,10 +21335,12 @@ exports.resolveStorageNameToSchemaName = resolveStorageNameToSchemaName;
 exports.runDestroyLifecycle = runDestroyLifecycle;
 exports.runSeedInit = runSeedInit;
 exports.saveModelsFromMarkdown = saveModelsFromMarkdown;
+exports.scheduleBulkFilesDownloadFromEasSync = scheduleBulkFilesDownloadFromEasSync;
 exports.schema = schema$1;
 exports.schema$1 = schema;
 exports.schemas = schemas;
 exports.seeds = seeds;
+exports.setSchemaUidForSchemaDefinition = setSchemaUidForSchemaDefinition;
 exports.setupEntityLiveQuery = setupEntityLiveQuery;
 exports.syncSchemaFromSource = syncSchemaFromSource;
 exports.toSnakeCase = toSnakeCase;
@@ -20483,4 +21350,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-D1qR8xnb.js.map
+//# sourceMappingURL=index-C6rrqy3z.js.map