@seedprotocol/sdk 0.6.7 → 0.6.9

package/dist/{ClientManager-Y5EWQuJj.js → ClientManager-ChcmUL47.js}

@@ -1,11 +1,11 @@
 import debug from 'debug';
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot, fromPromise } from 'xstate';
-import { n as normalizePublisher, o as getOwnedAddressesFromDb, j as normalizeAddressList, b as normalizeHexAddress, h as getAddressesForItemsFilter, e as escapeSqliteString, g as getPropertyIdForModelAndName, i as normalizeAddressConfig, m as loadModelsFromDbForSchema, l as addSchemaToDb, p as getWatchedAddressesFromDb } from './db-CceyWksv.js';
-import { n as normalizeDataType, t as toSnakeCase, p as MachineIds, A as getStorageTransactionIdForSeedUid, G as convertTxIdToImage, v as ensureImageLocal, K as downloadTransactionIdWithDedupe, M as ModelPropertyDataTypes, O as getDataTypeFromString, Q as getMimeType, m as eventEmitter, l as getCorrectId, S as isBrowser, U as isNode, V as downloadAllFilesRequestHandler, W as downloadAllFilesBinaryRequestHandler, X as ClientManagerEvents, C as ClientManagerState } from './constants-DSqHBPNe.js';
-import { a as BaseDb, r as seeds, j as modelUids, m as models$1, v as versions, b as metadata$1, s as schemas, i as modelSchemas, Z as ZERO_BYTES32, B as BaseFileManager, I as INTERNAL_PROPERTY_NAMES, C as ImageSize, p as properties, x as INTERNAL_DATA_TYPES, P as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, f as easSyncProcesses, t as BasePathResolver, c as appState, G as isInternalSchema, H as INTERNAL_SCHEMA_IDS, D as SEED_PROTOCOL_SCHEMA_NAME, h as htmlEmbeddedImageCoPublish, d as arweaveL1FinalizeJobs, q as publishProcesses, J as CLIENT_NOT_INITIALIZED } from './BasePathResolver-qV0apdVY.js';
-import { and, isNotNull, not, eq, or, max, count, getTableColumns, sql, isNull, desc, inArray, gt } from 'drizzle-orm';
-import { getResolvedSeedGatewayEndpoints, getReadGatewayHostsForConfig, getDefaultArweaveReadGatewayHostsOrdered, getArweaveReadGatewayHostsForPrimary, seedGatewayConfigFromSeedConfig, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
-import { BaseQueryClient, BaseEasClient, GET_SCHEMAS, getSchemaUidForModelFromCache, setSchemaUidForModel, GET_PROPERTIES, pickLatestPropertyAttestationsByRefAndSchema, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, GET_SCHEMA_BY_NAME } from '@seedprotocol/eas';
+import { n as normalizeDataType, o as normalizePublisher, G as getOwnedAddressesFromDb, x as normalizeAddressList, r as normalizeHexAddress, v as getAddressesForItemsFilter, k as isDataType, M as ModelPropertyDataTypes, q as escapeSqliteString, K as getPropertyIdForSchemaFileId, m as getPropertyIdForModelAndName, l as normalizePropertyRecordSchema, w as normalizeAddressConfig, E as loadModelsFromDbForSchema, A as addSchemaToDb, O as getWatchedAddressesFromDb } from './db-WbrzEf7c.js';
+import { a as BaseDb, r as seeds, j as modelUids, m as models$1, v as versions, b as metadata$1, s as schemas, i as modelSchemas, Z as ZERO_BYTES32, B as BaseFileManager, I as INTERNAL_PROPERTY_NAMES, C as ImageSize, p as properties, x as INTERNAL_DATA_TYPES, P as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, f as easSyncProcesses, t as BasePathResolver, c as appState, J as isInternalSchema, K as INTERNAL_SCHEMA_IDS, D as SEED_PROTOCOL_SCHEMA_NAME, h as htmlEmbeddedImageCoPublish, d as arweaveL1FinalizeJobs, q as publishProcesses, L as CLIENT_NOT_INITIALIZED } from './BasePathResolver-B6CKqoKw.js';
+import { and, isNotNull, not, eq, or, max, count, getTableColumns, sql, isNull, desc, inArray, gt, ne } from 'drizzle-orm';
+import { t as toSnakeCase, m as getStorageTransactionIdForSeedUid, o as convertTxIdToImage, f as ensureImageLocal, p as downloadTransactionIdWithDedupe, q as getDataTypeFromString, u as getMimeType, e as eventEmitter, g as getCorrectId, a as isStorageSeedRef, v as isNode, w as isBrowser, x as downloadAllFilesRequestHandler, y as downloadAllFilesBinaryRequestHandler } from './index-280bL-n4.js';
+import { fetchArweaveRawTextAcrossGateways, seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
+import { BaseQueryClient, BaseEasClient, GET_SCHEMAS, getSchemaUidForModelFromCache, setSchemaUidForModel, GET_PROPERTIES, pickLatestPropertyAttestationsByRefAndSchema, isValidEasAttestationUid, isPlaceholderUid, getEasSchemaUidForSchemaDefinition, GET_SCHEMA_BY_NAME, configureEasReadChain, isEasReadChainConfigured, getEasReadChainId, whenEasReadChainSettled, DEFAULT_EAS_CHAIN_ID } from '@seedprotocol/eas';
 import pluralize from 'pluralize';
 import { sha3_256 } from '@noble/hashes/sha3';
 import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils';
@@ -132,20 +132,34 @@ var publishConfig = /*#__PURE__*/Object.freeze({
     setUploadExecutor: setUploadExecutor
 });
 
-/**
- * For a schema property key like `authors` (List of Relation to Identity), returns the
- * internal storage/EAS name: `authorIdentityIds` (singular + ref + Ids).
- */
-function listRelationStoragePropertyName(propertySchemas, schemaPropertyKey) {
-    const propDef = propertySchemas[schemaPropertyKey];
+/** Ref model name when propDef is a List of Relation, else undefined. */
+function listRelationRef(propDef) {
     if (!propDef)
         return undefined;
     if (normalizeDataType(propDef.dataType) !== 'List')
         return undefined;
-    const ref = propDef.ref || propDef.refModelName;
-    if (!ref)
+    return propDef.ref || propDef.refModelName || undefined;
+}
+/**
+ * Storage/EAS name for a List-of-relation property (`authorIdentityIds`), given either its
+ * schema key (`authors`) or its storage name. A name already in storage form is returned as-is,
+ * so this is safe on ItemProperties built before their schema was known.
+ * Returns undefined when propDef is not a List of Relation.
+ */
+function listRelationEasPropertyName(propertyName, propDef) {
+    const ref = listRelationRef(propDef);
+    if (!ref || !propertyName)
         return undefined;
-    return `${pluralize(schemaPropertyKey, 1)}${ref}Ids`;
+    if (propertyName.endsWith(`${ref}Ids`))
+        return propertyName;
+    return `${pluralize(propertyName, 1)}${ref}Ids`;
+}
+/**
+ * For a schema property key like `authors` (List of Relation to Identity), returns the
+ * internal storage/EAS name: `authorIdentityIds` (singular + ref + Ids).
+ */
+function listRelationStoragePropertyName(propertySchemas, schemaPropertyKey) {
+    return listRelationEasPropertyName(schemaPropertyKey, propertySchemas[schemaPropertyKey]);
 }
 /**
  * Reverse of listRelationStoragePropertyName: maps DB/EAS name `authorIdentityIds` to schema key `authors`.
@@ -367,6 +381,95 @@ function createReactiveProxy(config) {
     return proxy;
 }
 
+const ENV = (typeof process !== 'undefined' && process.env)
+    ? process.env
+    : (typeof window !== 'undefined' && window.env)
+        ? window.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";
+    MachineIds["ITEM"] = "@seedSdk/item";
+    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
+    MachineIds["MODEL"] = "@seedSdk/model";
+    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
+})(MachineIds || (MachineIds = {}));
+const { INTERNAL, GLOBAL, EAS, MODEL } = MachineIds;
+var ClientManagerState;
+(function (ClientManagerState) {
+    ClientManagerState["UNINITIALIZED"] = "uninitialized";
+    ClientManagerState["PLATFORM_CLASSES_INIT"] = "platformClassesInit";
+    ClientManagerState["FILE_SYSTEM_INIT"] = "fileSystemInit";
+    ClientManagerState["DB_INIT"] = "dbInit";
+    ClientManagerState["SAVE_CONFIG"] = "saveConfig";
+    ClientManagerState["ADD_MODELS_TO_STORE"] = "addModelsToStore";
+    ClientManagerState["ADD_MODELS_TO_DB"] = "addModelsToDb";
+    ClientManagerState["PROCESS_SCHEMA_FILES"] = "processSchemaFiles";
+    ClientManagerState["IDLE"] = "idle";
+    ClientManagerState["INIT_FAILED"] = "initFailed";
+})(ClientManagerState || (ClientManagerState = {}));
+var ClientManagerEvents;
+(function (ClientManagerEvents) {
+    ClientManagerEvents["UPDATE_CONTEXT"] = "updateContext";
+    ClientManagerEvents["PLATFORM_CLASSES_READY"] = "platformClassesReady";
+    ClientManagerEvents["FILE_SYSTEM_READY"] = "fileSystemReady";
+    ClientManagerEvents["DB_READY"] = "dbReady";
+    ClientManagerEvents["SAVE_CONFIG_SUCCESS"] = "saveConfigSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_SUCCESS"] = "saveAppStateSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_ERROR"] = "saveAppStateError";
+    ClientManagerEvents["SET_ADDRESSES"] = "setAddresses";
+    ClientManagerEvents["ADD_MODELS_TO_STORE_SUCCESS"] = "addModelsToStoreSuccess";
+    ClientManagerEvents["ADD_MODELS_TO_DB_SUCCESS"] = "addModelsToDbSuccess";
+    ClientManagerEvents["PROCESS_SCHEMA_FILES_SUCCESS"] = "processSchemaFilesSuccess";
+})(ClientManagerEvents || (ClientManagerEvents = {}));
+var GlobalState;
+(function (GlobalState) {
+    GlobalState["UNINITIALIZED"] = "uninitialized";
+    GlobalState["INITIALIZING"] = "initializing";
+    GlobalState["INITIALIZED"] = "initialized";
+    GlobalState["PUBLISHING_ITEM"] = "publishingItem";
+    GlobalState["ADDING_MODELS_TO_DB"] = "addingModelsToDb";
+})(GlobalState || (GlobalState = {}));
+const { UNINITIALIZED: GLOBAL_UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
+var InternalState;
+(function (InternalState) {
+    InternalState["IDLE"] = "idle";
+    InternalState["INITIALIZING"] = "initializing";
+    InternalState["VALIDATING_INPUT"] = "validatingInput";
+    InternalState["CONFIGURING_FS"] = "configuringFs";
+    InternalState["LOADING_SEED_DB"] = "loadingSeedDb";
+    InternalState["SAVING_CONFIG"] = "savingConfig";
+    InternalState["LOADING_APP_DB"] = "loadingAppDb";
+    InternalState["LOADING_SDK_DB"] = "loadingSdkDb";
+})(InternalState || (InternalState = {}));
+const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } = InternalState;
+var PublishMachineStates;
+(function (PublishMachineStates) {
+    PublishMachineStates["VALIDATING_ITEM_DATA"] = "validatingItemData";
+    PublishMachineStates["CREATING_PUBLISH_ATTEMPT"] = "creatingPublishAttempt";
+    PublishMachineStates["UPLOADING"] = "uploading";
+    PublishMachineStates["PREPARING_PUBLISH_REQUEST_DATA"] = "preparingPublishRequestData";
+    PublishMachineStates["PUBLISHING"] = "publishing";
+    PublishMachineStates["IDLE"] = "idle";
+})(PublishMachineStates || (PublishMachineStates = {}));
+/**
+ * @deprecated Evaluated once at import and ignores `SeedConfig.eas` / publish chain config.
+ * Use `getEasEndpoint()` from `@seedprotocol/eas`.
+ */
+ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
+    ENV.EAS_ENDPOINT ||
+    'https://optimism-sepolia.easscan.org/graphql';
+/**
+ * @deprecated Use BaseArweaveClient.getHost() instead.
+ * 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 || 'ar.seedprotocol.io';
+
 debug('seedSdk:item:service:actors:waitForDb');
 const waitForDb$1 = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
@@ -665,7 +768,7 @@ const fetchDataFromEas = fromCallback(({ sendBack, input: { context } }) => {
         }
         else if (modelName) {
             // Dynamic import to break circular dependency
-            const _mod_0 = await import('./index-BFpbtEsg.js');
+            const _mod_0 = await import('./index-HRHkbVQd.js');
             const _ns_0 = _mod_0.b;
             const modelMod = _ns_0;
             const { Model } = modelMod;
@@ -854,7 +957,7 @@ function compareMetadataRowsLatestFirst(a, b) {
     return kb.localId.localeCompare(ka.localId);
 }
 
-const logger$j = debug('seedSdk:item:actors:loadOrCreateItem');
+const logger$k = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
  */
@@ -928,7 +1031,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
         const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
-        const _mod_1 = await import('./index-BFpbtEsg.js');
+        const _mod_1 = await import('./index-HRHkbVQd.js');
         const _ns_1 = _mod_1.b;
         const { Model } = _ns_1;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
@@ -946,18 +1049,18 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_2 = await import('./Schema-BYM-GNdE.js');
+                    const _mod_2 = await import('./Schema-a8uO-hIZ.js');
                     const _ns_2 = _mod_2.b;
                     const { Schema } = _ns_2;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
                         propertySchemas = schemaContext.models[modelName].properties;
-                        logger$j(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
+                        logger$k(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
                     }
                 }
                 catch (err) {
-                    logger$j(`Fallback Schema context failed for ${modelName}: ${err}`);
+                    logger$k(`Fallback Schema context failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
@@ -968,20 +1071,20 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const models = schemaFile.models;
                         if (models?.[modelName]?.properties) {
                             propertySchemas = models[modelName].properties;
-                            logger$j(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
+                            logger$k(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$j(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
+                    logger$k(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
                     const { listCompleteSchemaFiles } = await Promise.resolve().then(function () { return schema; });
-                    const _mod_3 = await import('./BasePathResolver-qV0apdVY.js');
-                    const _ns_3 = _mod_3.K;
+                    const _mod_3 = await import('./BasePathResolver-B6CKqoKw.js');
+                    const _ns_3 = _mod_3.N;
                     const { BaseFileManager } = _ns_3;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -989,17 +1092,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const schemaFile = JSON.parse(content);
                         if (schemaFile.models?.[modelName]?.properties) {
                             propertySchemas = schemaFile.models[modelName].properties;
-                            logger$j(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
+                            logger$k(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$j(`Fallback schema file scan failed for ${modelName}: ${err}`);
+                    logger$k(`Fallback schema file scan failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-CHi212ST.js');
+                const schemaMod = await import('./index-ClSv5pTA.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -1011,10 +1114,13 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 };
                 if (KNOWN_MODEL_FALLBACKS[modelName]) {
                     propertySchemas = KNOWN_MODEL_FALLBACKS[modelName];
-                    logger$j(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
+                    logger$k(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
                 }
             }
         }
+        // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
+        const { normalizePropertyRecordSchema } = await import('./property-CQjuZ4JW.js');
+        propertySchemas = Object.fromEntries(Object.entries(propertySchemas).map(([name, def]) => [name, normalizePropertyRecordSchema(def)]));
         // Collapse rows that map to the same instance key (e.g. authorIdentityIds + authors -> authors).
         // ItemProperty.create cache does not sync propertyValue on hit; processing order would otherwise
         // let an empty "authors" row overwrite a populated storage row.
@@ -1026,7 +1132,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             try {
                 let propertyName = metaRow.propertyName;
                 if (!propertyName) {
-                    logger$j(`Metadata row missing propertyName, skipping`);
+                    logger$k(`Metadata row missing propertyName, skipping`);
                     continue;
                 }
                 const listSchemaKey = resolveStorageNameToSchemaName(propertySchemas, propertyName);
@@ -1046,7 +1152,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-CHi212ST.js');
+                    const schemaMod = await import('./index-ClSv5pTA.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -1074,14 +1180,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$j(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
+                    logger$k(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$j(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
+                    logger$k(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
-                logger$j(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
+                logger$k(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
             }
         }
         // Create placeholder ItemProperty instances for model schema properties without metadata
@@ -1103,17 +1209,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$j(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
+                    logger$k(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
                 }
             }
             catch (error) {
-                logger$j(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
+                logger$k(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
             }
         }
-        logger$j(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
+        logger$k(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
     }
     catch (error) {
-        logger$j(`Error in createItemPropertyInstances: ${error}`);
+        logger$k(`Error in createItemPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
     return propertyInstances;
@@ -1121,7 +1227,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
 const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        logger$j(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$k(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -1151,7 +1257,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .limit(1);
         if (seedRecords.length === 0) {
             // Seed not found - this is a new item, will be created elsewhere
-            logger$j(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+            logger$k(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1192,7 +1298,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .where(eq(seeds.localId, resolvedSeedLocalId))
             .limit(1);
         if (versionRecords.length === 0) {
-            logger$j(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$k(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1216,7 +1322,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         const latestVersionLocalId = versionRecord.latestVersionLocalId;
         const latestVersionUid = versionRecord.latestVersionUid || undefined;
         if (!latestVersionLocalId) {
-            logger$j(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$k(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1247,7 +1353,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .select()
             .from(metadataLatest)
             .where(eq(metadataLatest.rowNum, 1));
-        logger$j(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
+        logger$k(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
         // Step 4: Create ItemProperty instances from metadata records + placeholders for model schema properties
         // Always call when we have a valid version so placeholders are created for properties without metadata
         const propertyInstances = await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid, modelName, latestVersionLocalId, latestVersionUid);
@@ -1279,7 +1385,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         });
     };
     _loadOrCreateItem().catch((error) => {
-        logger$j(`Error in loadOrCreateItem: ${error}`);
+        logger$k(`Error in loadOrCreateItem: ${error}`);
         sendBack({
             type: 'loadOrCreateItemError',
             error: error instanceof Error ? error.message : String(error),
@@ -1287,7 +1393,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$i = debug('seedSdk:Item:runPublish');
+const logger$j = debug('seedSdk:Item:runPublish');
 const runPublish = fromCallback(({ sendBack, input: { context } }) => {
     const { seedLocalId } = context;
     const _runPublish = async () => {
@@ -1303,9 +1409,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-AKISt3JA.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-C6cDeZdz.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-2gnnDdMh.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BIrTVUxb.js');
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -1321,12 +1427,12 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             await getPublishPayload(item, uploadedTransactions);
-            logger$i('runPublish: payload prepared (upload/EAS submit stubbed)');
+            logger$j('runPublish: payload prepared (upload/EAS submit stubbed)');
             sendBack({ type: 'publishSuccess' });
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            logger$i('runPublish error:', error);
+            logger$j('runPublish error:', error);
             sendBack({ type: 'publishError', error });
         }
     };
@@ -1685,7 +1791,7 @@ async function getLatestPublishedVersionRow(seedLocalId) {
     return null;
 }
 
-const logger$h = debug('seedSdk:db:read:getItemData');
+const logger$i = debug('seedSdk:db:read:getItemData');
 /**
  * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
  *
@@ -1701,7 +1807,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$h('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$i('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId || undefined;
@@ -1728,9 +1834,9 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .from(seeds)
         .where(and(...whereClauses))
         .limit(1);
-    logger$h('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
+    logger$i('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
     if (!seedRows || seedRows.length === 0) {
-        logger$h('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
+        logger$i('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
         return;
     }
     const seedRow = seedRows[0];
@@ -1752,7 +1858,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
             }
         }
         catch (error) {
-            logger$h('[getItemData] Error deriving schemaName:', error);
+            logger$i('[getItemData] Error deriving schemaName:', error);
         }
     }
     // Now get version data if it exists - query versions table directly
@@ -2141,12 +2247,12 @@ const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-const logger$g = debug('seedSdk:ItemProperty:service:actors:waitForDb');
+const logger$h = debug('seedSdk:ItemProperty:service:actors:waitForDb');
 const waitForDb = fromCallback(({ sendBack }) => {
     // Check immediately first
     const appDb = BaseDb.getAppDb();
     if (appDb) {
-        logger$g('Database is ready (immediate check)');
+        logger$h('Database is ready (immediate check)');
         sendBack({ type: 'waitForDbSuccess' });
         return;
     }
@@ -2158,24 +2264,24 @@ const waitForDb = fromCallback(({ sendBack }) => {
             const appDb = BaseDb.getAppDb();
             if (appDb) {
                 clearInterval(interval);
-                logger$g('Database is ready (after polling)');
+                logger$h('Database is ready (after polling)');
                 resolve();
             }
             else if (Date.now() - startTime > timeout) {
                 clearInterval(interval);
                 const error = new Error('Database not available after timeout');
-                logger$g(`Database wait timeout: ${error.message}`);
+                logger$h(`Database wait timeout: ${error.message}`);
                 reject(error);
             }
         }, 100);
     });
     _waitForDb
         .then(() => {
-        logger$g('Sending waitForDbSuccess event');
+        logger$h('Sending waitForDbSuccess event');
         sendBack({ type: 'waitForDbSuccess' });
     })
         .catch((error) => {
-        logger$g(`Error waiting for database: ${error}`);
+        logger$h(`Error waiting for database: ${error}`);
         sendBack({ type: 'waitForDbError', error: error.message });
     });
 });
@@ -2269,7 +2375,7 @@ const getRelationValueData = async (propertyValue) => {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> resolveRelatedValue -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$f = debug('seedSdk:property:actors:resolveRelatedValue');
+const logger$g = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -2277,14 +2383,14 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CHi212ST.js');
+        const schemaMod = await import('./index-ClSv5pTA.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$f(`${propertyName} value is an array of seedUids`);
+            logger$g(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (typeof propertyValue === 'object') {
@@ -2296,7 +2402,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             parsedValue = JSON.parse(relationKey);
         }
         catch (error) {
-            logger$f(`${propertyName} value is not a JSON string.`);
+            logger$g(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(relationKey)) {
             const contentUrl = seedUidToContentUrl.get(relationKey);
@@ -2311,7 +2417,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             return true;
         }
         if (Array.isArray(parsedValue)) {
-            logger$f(`${propertyName} value is a stringified array of seedUids`);
+            logger$g(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(relationKey);
@@ -2351,7 +2457,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             // This handles a local-only relation value and resolves from the filesystem
             if (refResolvedValue &&
                 propertyRecordSchema &&
-                propertyRecordSchema.dataType === ModelPropertyDataTypes.Relation &&
+                isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Relation) &&
                 propertyValueFromDb &&
                 typeof propertyValueFromDb === 'string' &&
                 propertyValueFromDb.length === 10 &&
@@ -2654,48 +2760,15 @@ function extractArweaveTransactionId(raw) {
     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.
+ * GET /raw/{txId} on each read gateway, preferred ones ({@link setPreferredArweaveReadBaseUrls})
+ * first. Avoids arweave.js /tx/.../offset which often 404s on arweave.net while another gateway
+ * (e.g. ar.seedprotocol.io, or the one the item was just uploaded through) still serves the data.
  */
 async function fetchHtmlViaRawAcrossGateways(txId) {
     const id = extractArweaveTransactionId(txId);
     if (!id || SEED_UID_HEX_RE.test(id))
         return undefined;
-    try {
-        const resolved = getResolvedSeedGatewayEndpoints();
-        if (!resolved || (resolved.activePath !== 'hyper-sidecar' && resolved.activePath !== 'http-proxy')) {
-            const { ensureReadGatewaySelected } = await import('@seedprotocol/arweave');
-            await ensureReadGatewaySelected().catch(() => { });
-        }
-    }
-    catch {
-        /* optional */
-    }
-    const { BaseArweaveClient } = await import('@seedprotocol/arweave');
-    const protocol = BaseArweaveClient.getProtocol();
-    const resolved = getResolvedSeedGatewayEndpoints();
-    const hosts = resolved
-        ? getReadGatewayHostsForConfig(resolved, getDefaultArweaveReadGatewayHostsOrdered())
-        : getArweaveReadGatewayHostsForPrimary(BaseArweaveClient.getHost());
-    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;
+    return fetchArweaveRawTextAcrossGateways(id);
 }
 /**
  * Resolve the Html storage seed's `local_id` used for the `{localId}.html` file name.
@@ -2745,8 +2818,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_4 = await import('./constants-DSqHBPNe.js');
-        const _ns_4 = _mod_4.Y;
+        const _mod_4 = await import('./index-280bL-n4.js');
+        const _ns_4 = _mod_4.z;
         const { downloadTransactionIdWithDedupe } = _ns_4;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -2795,7 +2868,7 @@ async function readHtmlBodyForStorageSeedPropertyValue(propertyValue) {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$e = debug('seedSdk:property:actors:hydrateFromDb');
+const logger$f = debug('seedSdk:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
     if (!propertyNameRaw) {
@@ -2806,7 +2879,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CHi212ST.js');
+        const schemaMod = await import('./index-ClSv5pTA.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2912,7 +2985,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     }
                 }
                 catch (e) {
-                    logger$e('[hydrateFromDb] Image file resolution error', e);
+                    logger$f('[hydrateFromDb] Image file resolution error', e);
                 }
             }
         }
@@ -2943,7 +3016,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (e) {
-                logger$e('[hydrateFromDb] File resolution error', e);
+                logger$f('[hydrateFromDb] File resolution error', e);
             }
         }
         if (propertyRecordSchema &&
@@ -3046,11 +3119,11 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$d = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$e = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$d(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$e(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -3085,7 +3158,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_5 = await import('./index-BFpbtEsg.js');
+                    const _mod_5 = await import('./index-HRHkbVQd.js');
                     const _ns_5 = _mod_5.b;
                     const { Model } = _ns_5;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -3098,15 +3171,15 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         const schemas = modelPropertiesToObject(model.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$d(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$e(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$d(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$e(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$d(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$e(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -3172,15 +3245,15 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-CWKcZ5YZ.js');
+                            const { getPropertySchema } = await import('./property-CQjuZ4JW.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
-                                const _mod_6 = await import('./BasePathResolver-qV0apdVY.js');
-                                const _ns_6 = _mod_6.L;
+                                const _mod_6 = await import('./BasePathResolver-B6CKqoKw.js');
+                                const _ns_6 = _mod_6.O;
                                 const { schemas: schemasTable } = _ns_6;
-                                const _mod_7 = await import('./BasePathResolver-qV0apdVY.js');
-                                const _ns_7 = _mod_7.N;
+                                const _mod_7 = await import('./BasePathResolver-B6CKqoKw.js');
+                                const _ns_7 = _mod_7.Q;
                                 const { modelSchemas } = _ns_7;
                                 const modelSchemaRows = await db
                                     .select({ schemaId: modelSchemas.schemaId })
@@ -3214,13 +3287,13 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (error) {
-                logger$d(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$e(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_8 = await import('./index-BFpbtEsg.js');
+                const _mod_8 = await import('./index-HRHkbVQd.js');
                 const _ns_8 = _mod_8.b;
                 const { Model } = _ns_8;
                 const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -3234,12 +3307,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                     const schemas = modelPropertiesToObject(model.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$d(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$e(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$d(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$e(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
             }
         }
         // For Html: read file content for renderValue (propertyValue is seed ID; blob URLs in DB are invalid after reload)
@@ -3280,7 +3353,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$d(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$e(`Failed to read Html file for ${propertyName}: ${e}`);
             }
         }
         // Covers missing ref row, wrong ref, or DB dataType casing "html" (handled by isHtml above).
@@ -3338,7 +3411,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         });
                     }
                     catch (e) {
-                        logger$d(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
+                        logger$e(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
                     }
                 }
             }
@@ -3360,7 +3433,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$d(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$e(`Failed to resolve Image file for ${propertyName}: ${e}`);
             }
         }
         const isFile = refSeedType === 'file' ||
@@ -3378,7 +3451,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$d(`Failed to resolve File for ${propertyName}: ${e}`);
+                logger$e(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -3410,7 +3483,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$d(`Error in loadOrCreateProperty: ${error}`);
+        logger$e(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -3440,10 +3513,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$c = debug('seedSdk:write:updateItemPropertyValue');
+const logger$d = debug('seedSdk:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, dataType, refValueType, }) => {
     if (!localIdParam && !seedLocalId) {
-        logger$c(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$d(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -3516,7 +3589,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$c(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$d(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
             return;
         }
         // This means we already have a local-only record so we should just update that one
@@ -3644,9 +3717,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CHi212ST.js');
+        const schemaMod = await import('./index-ClSv5pTA.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-Dr6nmwPm.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-Y49vqast.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3821,6 +3894,12 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
     if (!metadataValues.modelType && metadataValues.modelName) {
         metadataValues.modelType = toSnakeCase$1(metadataValues.modelName);
     }
+    // List of Relation rows live under the storage name (authors → authorIdentityIds), never the schema key.
+    if (metadataValues.propertyName) {
+        const storageName = listRelationEasPropertyName(metadataValues.propertyName, propertyRecordSchema);
+        if (storageName)
+            metadataValues.propertyName = storageName;
+    }
     const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage';
     // if (
     //   propertyRecordSchema &&
@@ -3835,7 +3914,11 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
     // }
     // Convert propertyValue to string if it's not already (metadata table expects text)
     if (metadataValues.propertyValue !== undefined && metadataValues.propertyValue !== null) {
-        if (typeof metadataValues.propertyValue !== 'string') {
+        if (Array.isArray(metadataValues.propertyValue)) {
+            // List values: JSON array is the storage format (String() would give legacy comma-separated ids)
+            metadataValues.propertyValue = JSON.stringify(metadataValues.propertyValue);
+        }
+        else if (typeof metadataValues.propertyValue !== 'string') {
             metadataValues.propertyValue = String(metadataValues.propertyValue);
         }
     }
@@ -3844,7 +3927,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-Dr6nmwPm.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-Y49vqast.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -3895,29 +3978,44 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
             }
         }
     }
-    // Resolve property_id for FK: prefer explicit value, then propertyRecordSchema.id, else lookup
+    // Resolve property_id for FK: prefer explicit value, then propertyRecordSchema.id, else lookup.
+    // propertyRecordSchema.id is the integer properties.id only when built from a DB row; from schema
+    // files and Model it is the schemaFileId string, which must be looked up (Number() gives NaN).
     if (metadataValues.propertyId == null) {
-        if (propertyRecordSchema?.id != null) {
-            metadataValues.propertyId =
-                typeof propertyRecordSchema.id === 'number'
-                    ? propertyRecordSchema.id
-                    : Number(propertyRecordSchema.id);
-        }
-        else if (metadataValues.propertyName &&
-            (metadataValues.modelName || metadataValues.modelType)) {
-            const modelKey = metadataValues.modelName ?? metadataValues.modelType;
-            metadataValues.propertyId =
-                (await getPropertyIdForModelAndName(modelKey, metadataValues.propertyName)) ?? undefined;
-        }
-    }
-    const inserted = await appDb
-        .insert(metadata$1)
-        .values({
-        ...metadataValues,
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-    })
-        .returning();
+        const schemaId = propertyRecordSchema?.id;
+        const modelKey = metadataValues.modelName ?? metadataValues.modelType ?? undefined;
+        if (typeof schemaId === 'number' && Number.isInteger(schemaId)) {
+            metadataValues.propertyId = schemaId;
+        }
+        else if (modelKey) {
+            if (typeof schemaId === 'string' && schemaId) {
+                metadataValues.propertyId =
+                    (await getPropertyIdForSchemaFileId(modelKey, schemaId)) ?? undefined;
+            }
+            if (metadataValues.propertyId == null && metadataValues.propertyName) {
+                metadataValues.propertyId =
+                    (await getPropertyIdForModelAndName(modelKey, metadataValues.propertyName)) ?? undefined;
+            }
+        }
+    }
+    let inserted;
+    try {
+        inserted = await appDb
+            .insert(metadata$1)
+            .values({
+            ...metadataValues,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        })
+            .returning();
+    }
+    catch (error) {
+        // Drizzle's message is the full SQL; the driver error that explains it is only on `cause`.
+        const cause = error?.cause;
+        const reason = cause instanceof Error ? cause.message : cause != null ? String(cause) : undefined;
+        throw new Error(`Failed to insert metadata for property ${metadataValues.propertyName}` +
+            (reason ? `: ${reason}` : `: ${error instanceof Error ? error.message : String(error)}`), { cause: error });
+    }
     if (!inserted || inserted.length === 0) {
         throw new Error(`Failed to insert metadata record for property ${metadataValues.propertyName}`);
     }
@@ -4437,7 +4535,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CHi212ST.js');
+        const schemaMod = await import('./index-ClSv5pTA.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -4450,7 +4548,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
         if (newValue instanceof File) {
             newValueType = 'file';
         }
-        if (propertyRecordSchema.dataType === ModelPropertyDataTypes.Image) {
+        if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Image)) {
             sendBack({
                 type: 'saveImage',
                 newValue,
@@ -4640,7 +4738,19 @@ const saveItemStorage = fromCallback(({ sendBack, input: { context, event } }) =
     });
 });
 
-// import { updateMachineContext } from '@/helpers'
+/**
+ * A List-of-relation schema can arrive after construction (item loaded before its model).
+ * Move the context to the storage name (staff → staffIdentityIds) so saves and publish use one name;
+ * ItemProperty keeps exposing the schema key.
+ */
+const withListRelationStorageName = (context) => {
+    if (!context.propertyName || !context.propertyRecordSchema)
+        return context;
+    const storageName = listRelationEasPropertyName(context.propertyName, normalizePropertyRecordSchema(context.propertyRecordSchema));
+    if (!storageName || storageName === context.propertyName)
+        return context;
+    return { ...context, propertyName: storageName, isRelation: true };
+};
 const propertyMachine = setup({
     types: {
         context: {},
@@ -4681,6 +4791,7 @@ const propertyMachine = setup({
             actions: assign({
                 isSaving: true,
                 _saveError: undefined,
+                _saveValidationErrors: undefined,
             }),
             target: '.saving',
         },
@@ -4694,7 +4805,9 @@ const propertyMachine = setup({
                     }
                     newContext[key] = event[key];
                 }
-                return newContext;
+                return 'propertyRecordSchema' in event
+                    ? withListRelationStorageName(newContext)
+                    : newContext;
             }),
         },
         destroyStarted: {
@@ -4753,7 +4866,7 @@ const propertyMachine = setup({
                     target: 'idle',
                     actions: assign(({ context, event }) => {
                         const property = event.property;
-                        return {
+                        return withListRelationStorageName({
                             ...context,
                             propertyName: property.propertyName || context.propertyName,
                             propertyValue: property.propertyValue !== undefined ? property.propertyValue : context.propertyValue,
@@ -4771,7 +4884,7 @@ const propertyMachine = setup({
                             refResolvedValue: property.refResolvedValue !== undefined ? property.refResolvedValue : context.refResolvedValue,
                             refResolvedDisplayValue: property.refResolvedDisplayValue !== undefined ? property.refResolvedDisplayValue : context.refResolvedDisplayValue,
                             localStorageDir: property.localStorageDir !== undefined ? property.localStorageDir : context.localStorageDir,
-                        };
+                        });
                     }),
                 },
                 loadOrCreatePropertyError: {
@@ -5002,7 +5115,7 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_9 = await import('./index-BFpbtEsg.js');
+            const _mod_9 = await import('./index-HRHkbVQd.js');
             const _ns_9 = _mod_9.b;
             const { Model } = _ns_9;
             const normalizedModelName = modelName;
@@ -5243,7 +5356,7 @@ const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, mod
         return undefined;
     }
     try {
-        const _mod_10 = await import('./index-BFpbtEsg.js');
+        const _mod_10 = await import('./index-HRHkbVQd.js');
         const _ns_10 = _mod_10.b;
         const { Model } = _ns_10;
         const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -5262,7 +5375,8 @@ const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, mod
             // Fallback: resolve from schema JSON when Model not in cache/DB (e.g. PermaPress sync failed but schema in DB)
             const schemaProp = await resolvePropertyRecordSchemaFromSchemaData(modelName, propertyName, modelType);
             if (schemaProp) {
-                return schemaProp;
+                // Schema JSON uses file shape ({ type: 'Html' }); callers read dataType.
+                return normalizePropertyRecordSchema(schemaProp);
             }
             return undefined;
         }
@@ -5282,7 +5396,7 @@ const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, mod
 };
 /** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
 const modelTypeToModelName = (modelType) => modelType ? upperFirst(camelCase(modelType)) : '';
-const logger$b = debug('seedSdk:property:class');
+const logger$c = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES$1 = [
@@ -5303,18 +5417,29 @@ const TRACKED_PROPERTIES$1 = [
 // WeakMap to store mutable state per ItemProperty instance
 // This avoids issues with read-only properties when instances are frozen by Immer
 const itemPropertyInstanceState = new WeakMap();
+/** Thrown by ItemProperty.save() when the value failed validation (enum, pattern, minLength, maxLength). */
+class ItemPropertySaveValidationError extends Error {
+    constructor(message, validationErrors) {
+        super(message);
+        this.validationErrors = validationErrors;
+        this.name = 'ItemPropertySaveValidationError';
+    }
+}
 class ItemProperty {
     constructor(initialValues) {
         this._isRelation = false;
         this._isList = false;
         this.find = ItemProperty.find;
         const { modelName, propertyName, propertyValue, seedLocalId, seedUid, versionLocalId, versionUid, storageTransactionId, schemaUid, refResolvedValue, refResolvedDisplayValue, localStorageDir, refSeedType } = initialValues;
+        // Fallback schema sources can hand us schema-file shape ({ type: 'html' }); everything below reads dataType.
+        const propertyRecordSchema = normalizePropertyRecordSchema(initialValues.propertyRecordSchema);
         if (!modelName) {
             throw new Error('Model name is required');
         }
         if (!propertyName) {
             throw new Error(`Property name not provided`);
         }
+        this._constructedPropertyName = propertyName;
         // ItemProperty no longer depends on Model - property schema will be loaded from database
         // via loadOrCreateProperty actor or can be provided in initialValues
         const serviceInput = {
@@ -5328,7 +5453,7 @@ class ItemProperty {
             storageTransactionId,
             // propertyRecordSchema will be loaded from database via loadOrCreateProperty actor
             // or can be provided in initialValues if available
-            propertyRecordSchema: initialValues.propertyRecordSchema,
+            propertyRecordSchema,
             schemaUid,
             isSaving: false,
             isRelation: false,
@@ -5340,16 +5465,13 @@ class ItemProperty {
         };
         // Property schema will be loaded from database via loadOrCreateProperty actor
         // For now, use propertyRecordSchema from initialValues if provided
-        const propertyRecordSchema = initialValues.propertyRecordSchema;
         if (propertyRecordSchema) {
-            this._dataType = propertyRecordSchema.dataType;
+            this._dataType = normalizeDataType(propertyRecordSchema.dataType);
             serviceInput.propertyRecordSchema = propertyRecordSchema;
-            // Use string literals to avoid circular dependency in constructor
-            // ModelPropertyDataTypes values are stable string constants
-            if (propertyRecordSchema.dataType === 'Relation') {
+            if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Relation)) {
                 this._isRelation = true;
             }
-            if (propertyRecordSchema.dataType === 'List') {
+            if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.List)) {
                 this._isList = true;
                 const listRef = propertyRecordSchema.ref ||
                     propertyRecordSchema.refModelName;
@@ -5364,7 +5486,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$b('List property value is not JSON', e);
+                        logger$c('List property value is not JSON', e);
                     }
                 }
             }
@@ -5387,7 +5509,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-CHi212ST.js');
+            const schemaMod = await import('./index-ClSv5pTA.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -5402,9 +5524,9 @@ class ItemProperty {
             }
             let renderValue;
             const isImage = propertyRecordSchema &&
-                propertyRecordSchema.dataType === ModelPropertyDataTypes.Image;
+                isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Image);
             const isFile = propertyRecordSchema &&
-                propertyRecordSchema.dataType === ModelPropertyDataTypes.File;
+                isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.File);
             const isItemStorage = propertyRecordSchema &&
                 propertyRecordSchema.storageType &&
                 propertyRecordSchema.storageType === 'ItemStorage' &&
@@ -5481,7 +5603,7 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$b(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$c(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = isHtml ? undefined : 'No file found';
                 }
             }
@@ -5558,7 +5680,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_11 = await import('./index-CsmiM0RI.js');
+                const _mod_11 = await import('./index-Djd3667v.js');
                 const _ns_11 = _mod_11.s;
                 const seedSchemaMod = _ns_11;
                 const { metadata } = seedSchemaMod;
@@ -5811,8 +5933,8 @@ class ItemProperty {
                             propertyRecordSchema,
                         });
                         // Update instance fields to match new schema (mirror constructor logic)
-                        this._dataType = propertyRecordSchema.dataType;
-                        if (propertyRecordSchema.dataType === 'Relation') {
+                        this._dataType = normalizeDataType(propertyRecordSchema.dataType);
+                        if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.Relation)) {
                             ;
                             this._isRelation = true;
                         }
@@ -5820,7 +5942,7 @@ class ItemProperty {
                             ;
                             this._isRelation = false;
                         }
-                        if (propertyRecordSchema.dataType === 'List') {
+                        if (isDataType(propertyRecordSchema.dataType, ModelPropertyDataTypes.List)) {
                             ;
                             this._isList = true;
                             this._isRelation = !!(propertyRecordSchema.ref);
@@ -5892,11 +6014,11 @@ class ItemProperty {
             // but cached instance doesn't (e.g. Item constructor created from schema first, then loadOrCreateItem
             // has metadata with refResolvedValue - we must not lose display data).
             const ctx = instance._getSnapshotContext();
-            const incomingSchema = props.propertyRecordSchema;
+            const incomingSchema = normalizePropertyRecordSchema(props.propertyRecordSchema);
             if (incomingSchema && !ctx.propertyRecordSchema) {
-                instance._dataType = incomingSchema.dataType;
-                instance._isRelation = incomingSchema.dataType === 'Relation';
-                instance._isList = incomingSchema.dataType === 'List';
+                instance._dataType = normalizeDataType(incomingSchema.dataType);
+                instance._isRelation = isDataType(incomingSchema.dataType, ModelPropertyDataTypes.Relation);
+                instance._isList = isDataType(incomingSchema.dataType, ModelPropertyDataTypes.List);
                 instance._service.send({
                     type: 'updateContext',
                     propertyRecordSchema: incomingSchema,
@@ -6099,7 +6221,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_12 = await import('./index-BFpbtEsg.js');
+                    const _mod_12 = await import('./index-HRHkbVQd.js');
                     const _ns_12 = _mod_12.b;
                     const { Model } = _ns_12;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -6116,7 +6238,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_13 = await import('./index-BFpbtEsg.js');
+                    const _mod_13 = await import('./index-HRHkbVQd.js');
                     const _ns_13 = _mod_13.b;
                     const { Model } = _ns_13;
                     const { modelPropertiesToObject } = await import('./model-DGMe-TTm.js');
@@ -6198,7 +6320,16 @@ class ItemProperty {
         if (this._alias) {
             return this._alias;
         }
-        return this._getSnapshotContext().propertyName || '';
+        const context = this._getSnapshotContext();
+        const name = context.propertyName || '';
+        // Built under its schema key before the schema was known, then renamed to the storage name
+        // (staff → staffIdentityIds) when a List-of-relation schema arrived: keep the schema key public.
+        if (this._constructedPropertyName &&
+            name !== this._constructedPropertyName &&
+            listRelationEasPropertyName(this._constructedPropertyName, context.propertyRecordSchema) === name) {
+            return this._constructedPropertyName;
+        }
+        return name;
     }
     /** DB / EAS / metadata column name (e.g. authorIdentityIds). Use for storage; prefer `propertyName` for public API. */
     get storagePropertyName() {
@@ -6235,7 +6366,7 @@ class ItemProperty {
     get status() {
         return this._getSnapshot().value;
     }
-    /** Validation errors from last failed save (enum, pattern, minLength, maxLength). Cleared on successful save. */
+    /** Validation errors from last failed save (enum, pattern, minLength, maxLength). Cleared when the next save starts. */
     get saveValidationErrors() {
         return this._getSnapshotContext()._saveValidationErrors ?? [];
     }
@@ -6273,11 +6404,17 @@ class ItemProperty {
         // If no propertyRecordSchema, try to resolve from Model before persisting (fixes external app persistence)
         if (!context.propertyRecordSchema) {
             const { modelName, propertyName, modelType } = context;
-            void resolvePropertyRecordSchemaFromModel(modelName ?? '', propertyName ?? '', modelType).then((schema) => {
-                if (schema) {
-                    this._service.send({ type: 'updateContext', propertyRecordSchema: schema });
-                    this._service.send({ type: 'save', newValue: value });
-                }
+            const pending = resolvePropertyRecordSchemaFromModel(modelName ?? '', propertyName ?? '', modelType).then((schema) => {
+                if (!schema)
+                    return false;
+                this._service.send({ type: 'updateContext', propertyRecordSchema: schema });
+                this._service.send({ type: 'save', newValue: value });
+                return true;
+            }, () => false);
+            this._pendingSchemaSave = pending;
+            void pending.finally(() => {
+                if (this._pendingSchemaSave === pending)
+                    this._pendingSchemaSave = undefined;
             });
         }
         else {
@@ -6307,9 +6444,23 @@ class ItemProperty {
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
         });
-        await waitFor(this._service, (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle', {
+        // Without this, save() would see `idle` before the deferred `save` event and resolve unsaved.
+        if (this._pendingSchemaSave && !(await this._pendingSchemaSave)) {
+            throw new Error(`Failed to save property ${ctx?.propertyName}: no schema found for ${ctx?.modelName}.${ctx?.propertyName}`);
+        }
+        const settled = await waitFor(this._service, (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle', {
             timeout: 10000,
         });
+        const { _saveError: saveError, _saveValidationErrors: validationErrors, propertyName } = settled.context;
+        if (saveError) {
+            const error = new Error(`Failed to save property ${propertyName}: ${saveError.message}`);
+            if (saveError.name)
+                error.name = saveError.name;
+            throw error;
+        }
+        if (validationErrors?.length) {
+            throw new ItemPropertySaveValidationError(`Invalid value for property ${propertyName}: ${validationErrors.map((e) => e.message).join('; ')}`, validationErrors);
+        }
         const canonicalId = ctx?.seedLocalId ?? ctx?.seedUid;
         if (canonicalId) {
             eventEmitter.emit('itemProperty.saved', { seedLocalId: ctx.seedLocalId, seedUid: ctx.seedUid });
@@ -6334,6 +6485,14 @@ class ItemProperty {
             if (cacheKey && cacheKey !== 'Item__') {
                 cacheKeys.push(cacheKey);
             }
+            // Renamed after construction (List of relation): also drop the entry cached under the old name.
+            const publicName = this.propertyName;
+            if (publicName && publicName !== context.propertyName) {
+                const aliasKey = ItemProperty.cacheKey(context.seedUid || context.seedLocalId || '', publicName);
+                if (aliasKey && aliasKey !== 'Item__' && ItemProperty.instanceCache.get(aliasKey)?.instance === this) {
+                    cacheKeys.push(aliasKey);
+                }
+            }
             unloadEntity(this, {
                 getCacheKeys: () => cacheKeys,
                 caches: [ItemProperty.instanceCache],
@@ -6395,7 +6554,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_14 = await import('./index-CsmiM0RI.js');
+                    const _mod_14 = await import('./index-Djd3667v.js');
                     const _ns_14 = _mod_14.s;
                     const seedSchemaMod = _ns_14;
                     const { metadata } = seedSchemaMod;
@@ -6429,7 +6588,8 @@ ItemProperty.instanceCache = new Map();
 
 var ItemProperty$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ItemProperty: ItemProperty
+    ItemProperty: ItemProperty,
+    ItemPropertySaveValidationError: ItemPropertySaveValidationError
 });
 
 // Dynamic import to break circular dependency: Model -> BaseItem -> createNewItem -> Model
@@ -6442,7 +6602,7 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     const newSeedId = await createSeed({ type: seedType });
     const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase$1(modelName) });
     // Dynamic import to break circular dependency
-    const _mod_15 = await import('./index-BFpbtEsg.js');
+    const _mod_15 = await import('./index-HRHkbVQd.js');
     const _ns_15 = _mod_15.b;
     const modelMod = _ns_15;
     const { Model } = modelMod;
@@ -6586,7 +6746,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_16 = await import('./index-BFpbtEsg.js');
+                const _mod_16 = await import('./index-HRHkbVQd.js');
                 const _ns_16 = _mod_16.b;
                 const mod = _ns_16;
                 ModelClass = mod.Model;
@@ -6619,6 +6779,15 @@ const getModel = () => {
 };
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
+/** Raw File/Image/Html content (not already a storage seed reference) needs ItemProperty.save(). */
+function needsStorageSavePipeline(dataType, value) {
+    if (value == null || value === '')
+        return false;
+    const isStorageType = isDataType(dataType, ModelPropertyDataTypes.File) ||
+        isDataType(dataType, ModelPropertyDataTypes.Image) ||
+        isDataType(dataType, ModelPropertyDataTypes.Html);
+    return isStorageType && !isStorageSeedRef(value);
+}
 const TRACKED_PROPERTIES = [
     'seedLocalId',
     'seedUid',
@@ -6710,12 +6879,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-AKISt3JA.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-C6cDeZdz.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await import('./getPublishPayload-2gnnDdMh.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BIrTVUxb.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -7176,6 +7345,7 @@ class Item {
         const schemaName = props.schemaName;
         // Get property names directly from database to make Item independent from Model
         let propertyNames = [];
+        const dataTypeByPropertyName = new Map();
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Query properties table directly by model name
@@ -7183,12 +7353,12 @@ class Item {
             let modelRecords;
             // If we have a schema name, join with modelSchemas to filter by schema
             if (schemaName) {
-                const _mod_17 = await import('./BasePathResolver-qV0apdVY.js');
-                const _ns_17 = _mod_17.N;
+                const _mod_17 = await import('./BasePathResolver-B6CKqoKw.js');
+                const _ns_17 = _mod_17.Q;
                 const modelSchemaSchemaMod = _ns_17;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_18 = await import('./BasePathResolver-qV0apdVY.js');
-                const _ns_18 = _mod_18.L;
+                const _mod_18 = await import('./BasePathResolver-B6CKqoKw.js');
+                const _ns_18 = _mod_18.O;
                 const schemaSchemaMod = _ns_18;
                 const { schemas: schemasTable } = schemaSchemaMod;
                 modelRecords = await db
@@ -7208,13 +7378,20 @@ class Item {
             }
             if (modelRecords.length > 0 && modelRecords[0].id) {
                 const propertyRecords = await db
-                    .select({ name: properties.name })
+                    .select({ name: properties.name, dataType: properties.dataType })
                     .from(properties)
                     .where(eq(properties.modelId, modelRecords[0].id));
                 propertyNames = propertyRecords.map((r) => r.name).filter((name) => Boolean(name));
+                for (const r of propertyRecords) {
+                    if (r.name && r.dataType)
+                        dataTypeByPropertyName.set(r.name, r.dataType);
+                }
             }
         }
         const modelPropertyData = { modelName: props.modelName };
+        // File/Image/Html values that are raw content (html string, data URI, URL, File) must go through
+        // the property's save pipeline to become storage seeds; createNewItem would store them verbatim.
+        const pipelineValues = [];
         // Only include properties that are in the model schema
         // Exclude modelInstance, modelName, and schemaName as they're metadata, not item properties
         for (const [key, value] of Object.entries(props)) {
@@ -7223,6 +7400,10 @@ class Item {
                 continue;
             }
             if (propertyNames.length === 0 || propertyNames.includes(key)) {
+                if (needsStorageSavePipeline(dataTypeByPropertyName.get(key), value)) {
+                    pipelineValues.push([key, value]);
+                    continue;
+                }
                 // If we couldn't get property names from DB, include all properties
                 // Type assertion: we've filtered out modelInstance above, so value should be a valid property value
                 modelPropertyData[key] = value;
@@ -7231,6 +7412,11 @@ class Item {
         const { seedLocalId, versionLocalId, } = await createNewItem(modelPropertyData);
         props.seedLocalId = seedLocalId;
         props.latestVersionLocalId = versionLocalId;
+        // Don't seed property instances with raw storage content: the value setter skips unchanged
+        // values, so savePipelineValues would never trigger a save.
+        for (const [key] of pipelineValues) {
+            delete props[key];
+        }
         // 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;
@@ -7330,7 +7516,8 @@ class Item {
             },
         });
         this.registerItemInInstanceCache(proxiedInstance);
-        if (!waitForReady)
+        // Storage values must be saved before returning, so wait for readiness even when not requested.
+        if (!waitForReady && pipelineValues.length === 0)
             return proxiedInstance;
         try {
             await this.waitForItemInstanceReadyForRead(proxiedInstance, readyTimeout);
@@ -7344,8 +7531,46 @@ class Item {
             }
             throw err;
         }
+        await this.savePipelineValues(proxiedInstance, pipelineValues, readyTimeout);
         return proxiedInstance;
     }
+    /**
+     * Run each File/Image/Html initial value through its ItemProperty save pipeline (sequentially, to
+     * avoid SQLite write contention). Rejects on the first failure; the item itself has been created.
+     */
+    static async savePipelineValues(item, pipelineValues, timeout) {
+        for (const [propertyName, value] of pipelineValues) {
+            const property = await this.waitForPropertyInstance(item, propertyName, timeout);
+            if (!property) {
+                throw new Error(`Item.create: property ${item.modelName}.${propertyName} did not load for item ${item.seedLocalId}; value was not saved`);
+            }
+            property.value = value;
+            try {
+                await property.save();
+            }
+            catch (error) {
+                throw new Error(`Item.create: failed to save ${item.modelName}.${propertyName} for item ${item.seedLocalId}: ` +
+                    (error instanceof Error ? error.message : String(error)), { cause: error });
+            }
+        }
+    }
+    static async waitForPropertyInstance(item, propertyName, timeout) {
+        const find = (ctx) => {
+            const instances = ctx?.propertyInstances;
+            const altKey = getAlternatePropertyNameForInstanceLookup(propertyName);
+            return instances?.get(propertyName) ?? (altKey ? instances?.get(altKey) : undefined);
+        };
+        const existing = find(item.getService().getSnapshot().context);
+        if (existing)
+            return existing;
+        try {
+            const snap = await waitFor(item.getService(), (s) => !!find(s.context), { timeout });
+            return find(snap.context);
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Get Item instance by ID from cache
      * The ID can be either seedUid or seedLocalId
@@ -7484,7 +7709,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_19 = await import('./index-CsmiM0RI.js');
+        const _mod_19 = await import('./index-Djd3667v.js');
         const _ns_19 = _mod_19.s;
         const { metadata } = _ns_19;
         const { eq, and } = await import('drizzle-orm');
@@ -7936,7 +8161,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_20 = await import('./index-CsmiM0RI.js');
+                const _mod_20 = await import('./index-Djd3667v.js');
                 const _ns_20 = _mod_20.s;
                 const seedSchemaMod = _ns_20;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -8368,7 +8593,7 @@ const runEasSync = fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await import('./syncDbWithEas-5kZneTEL.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-CuARXfyN.js');
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -8585,10 +8810,10 @@ var easSyncManager = /*#__PURE__*/Object.freeze({
     startEasSyncActor: startEasSyncActor
 });
 
-const logger$a = debug('seedSdk:services:events');
+const logger$b = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$a(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$b(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     // TODO: This is called from Node as well. Do we need it? If so, need to generalize this to all platforms.
     // localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
 };
@@ -8614,9 +8839,32 @@ const setupServiceHandlers = () => {
     eventEmitter.addListener('service.save', saveServiceHandler);
 };
 
-const logger$9 = debug('seedSdk:ClientManager:initialize');
+/**
+ * On Node, storage uses `filesDir`. `endpoints.filePaths` and `endpoints.files` are
+ * required by init but have no separate Node consumer, so fill them from `filesDir`.
+ * Browser configs are left unchanged.
+ */
+function normalizeSeedConfigEndpoints(config) {
+    if (!config)
+        return config;
+    const endpoints = config.endpoints;
+    if (endpoints?.filePaths && endpoints?.files)
+        return config;
+    if (!(isNode() && !isBrowser()))
+        return config;
+    const filesDir = config.filesDir;
+    if (!filesDir)
+        return config;
+    const next = {
+        filePaths: endpoints?.filePaths || filesDir,
+        files: endpoints?.files || filesDir,
+    };
+    return { ...config, endpoints: next };
+}
+
+const logger$a = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$9('initialize from ClientManager');
+    logger$a('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -8640,14 +8888,16 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         if (cancelled) {
             return;
         }
-        const { config, addresses } = options;
-        // Validate required endpoints - this should happen early in the initialization process
+        const { addresses } = options;
+        const config = normalizeSeedConfigEndpoints(options.config);
+        // Validate required endpoints - this should happen early in the initialization process.
+        // Node fills these from filesDir; browser callers still pass them.
         if (!config?.endpoints || !config.endpoints.filePaths || !config.endpoints.files) {
             throw new Error('Config must include endpoints with filePaths and files');
         }
         // Prefer the condition-resolved factory when available; fall back to explicit
         // platform imports so source/vitest resolution stays reliable.
-        const { configurePlatform } = await import('./configurePlatform-CCYQruij.js');
+        const { configurePlatform } = await import('./configurePlatform-CE0Vew17.js');
         if (isBrowser()) {
             const { createPlatformServices } = await import('./platform.browser.js');
             configurePlatform(createPlatformServices());
@@ -8663,13 +8913,20 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         if (cancelled) {
             return;
         }
-        const { models, endpoints, arweaveDomain, dbConfig, filesDir, schemaFile, schema, gateway, uploadApiBaseUrl } = config;
+        const { models, endpoints, arweaveDomain, dbConfig, filesDir, schemaFile, schema, gateway, uploadApiBaseUrl, eas } = config;
+        if (eas) {
+            configureEasReadChain('sdk', { chainId: eas.chainId, indexerUrl: eas.indexerUrl });
+        }
         const gatewayConfig = seedGatewayConfigFromSeedConfig({
             ...config,
             arweaveDomain,
             uploadApiBaseUrl,
             gateway,
         });
+        // Only when configured, so a host app's own setPreferredArweaveReadBaseUrls() call survives init.
+        if (gatewayConfig.preferredReadBaseUrls) {
+            setPreferredArweaveReadBaseUrls(gatewayConfig.preferredReadBaseUrls);
+        }
         const resolvedGateway = await resolveSeedGatewayEndpoints(gatewayConfig);
         setResolvedSeedGatewayEndpoints(resolvedGateway);
         BaseArweaveClient.setHost(`${resolvedGateway.arweaveProtocol}://${resolvedGateway.arweaveHost}`);
@@ -8775,7 +9032,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
     };
 });
 
-const logger$8 = debug('seedSdk:client:writeToDb');
+const logger$9 = debug('seedSdk:client:writeToDb');
 const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
@@ -8783,7 +9040,7 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$8('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$9('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -8799,13 +9056,13 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
                     value: JSON.stringify(value),
                 },
             });
-            logger$8('result', result);
+            logger$9('result', result);
         }
         catch (error) {
-            logger$8('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$9('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$8('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$9('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -8820,10 +9077,10 @@ const saveAppState = fromCallback(({ sendBack, input: { key, value } }) => {
         });
     })
         .catch((error) => {
-        logger$8('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$9('[client/actors] [saveAppState] Error in promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$8('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$9('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -8893,7 +9150,7 @@ const fileSystemInit = fromCallback(({ sendBack, input: { context }, }) => {
     };
 });
 
-const logger$7 = debug('seedSdk:client:actors:dbInit');
+const logger$8 = debug('seedSdk:client:actors:dbInit');
 const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     const _dbInit = async () => {
         const { filesDir } = context;
@@ -8907,14 +9164,14 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
         if (!appDb) {
             throw new Error('Database not available after preparation');
         }
-        logger$7('[client/actors] [dbInit] Database prepared and ready');
+        logger$8('[client/actors] [dbInit] Database prepared and ready');
     };
     _dbInit()
         .then(() => {
         sendBack({ type: ClientManagerEvents.DB_READY });
     })
         .catch((error) => {
-        logger$7('Error in dbInit:', error);
+        logger$8('Error in dbInit:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
@@ -8922,7 +9179,7 @@ const dbInit = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$6 = debug('seedSdk:client:actors:addModelsToStore');
+const logger$7 = debug('seedSdk:client:actors:addModelsToStore');
 const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
     const _addModelsToStore = async () => {
         let { models } = context;
@@ -8936,7 +9193,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [key] of Object.entries(allModels)) {
-            logger$6('model available:', key);
+            logger$7('model available:', key);
         }
     };
     _addModelsToStore()
@@ -8944,7 +9201,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
     })
         .catch((error) => {
-        logger$6('[client/actors] [addModelsToStore] Error:', error);
+        logger$7('[client/actors] [addModelsToStore] Error:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -8952,7 +9209,7 @@ const addModelsToStore = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$5 = debug('seedSdk:client:actors:addModelsToDb');
+const logger$6 = debug('seedSdk:client:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models } = context;
     const _addModelsToDb = async () => {
@@ -8990,14 +9247,14 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 existingByName.set(m.name, m);
             }
             for (const name of modelsToInsert) {
-                logger$5('[client/actors] [addModelsToDb] inserted model:', name);
+                logger$6('[client/actors] [addModelsToDb] inserted model:', name);
             }
         }
         let hasModelsInDb = true;
         for (const modelName of modelNames) {
             const foundModel = existingByName.get(modelName);
             if (!foundModel) {
-                logger$5('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                logger$6('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
                 hasModelsInDb = false;
                 continue;
             }
@@ -9008,7 +9265,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         }
         // If we have no models to process, still send success (empty models is valid)
         if (schemaDefsByModelName.size === 0) {
-            logger$5('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$6('[client/actors] [addModelsToDb] No models to process, but continuing');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
             return;
         }
@@ -9051,15 +9308,15 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$5('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                    logger$6('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
                 }
             }
             catch (error) {
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$5('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
+                    logger$6('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
                 }
                 else {
-                    logger$5('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                    logger$6('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 }
             }
         };
@@ -9071,10 +9328,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
     })
         .catch((error) => {
-        logger$5('[client/actors] [addModelsToDb] Error:', error);
+        logger$6('[client/actors] [addModelsToDb] Error:', error);
         // In test environments, still send success to allow initialization to complete
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$5('[client/actors] [addModelsToDb] Continuing despite error in test environment');
+            logger$6('[client/actors] [addModelsToDb] Continuing despite error in test environment');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
         else {
@@ -9087,6 +9344,102 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
+const logger$5 = debug('seedSdk:helpers:localDbChain');
+/** appState key recording which EAS chain the local database holds attestations from. */
+const EAS_CHAIN_ID_APP_STATE_KEY = 'easChainId';
+/**
+ * Databases written before the chain was recorded only ever held Optimism Sepolia data
+ * (the only chain the SDK supported then).
+ */
+const LEGACY_CHAIN_ID = DEFAULT_EAS_CHAIN_ID;
+async function readRecordedChainId(appDb) {
+    const rows = await appDb
+        .select({ value: appState.value })
+        .from(appState)
+        .where(eq(appState.key, EAS_CHAIN_ID_APP_STATE_KEY))
+        .limit(1);
+    const parsed = Number(rows[0]?.value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+async function recordChainId(appDb, chainId) {
+    const value = String(chainId);
+    await appDb
+        .insert(appState)
+        .values({ key: EAS_CHAIN_ID_APP_STATE_KEY, value })
+        .onConflictDoUpdate({ target: appState.key, set: { value } });
+}
+async function hasOnChainData(appDb) {
+    const rows = await appDb
+        .select({ uid: seeds.uid })
+        .from(seeds)
+        .where(and(isNotNull(seeds.uid), ne(seeds.uid, '')))
+        .limit(1);
+    return rows.length > 0;
+}
+/**
+ * Chain the local DB holds data from: the recorded one, or Optimism Sepolia for an unrecorded
+ * DB that already has attestations. Records the legacy value so later checks are cheap.
+ */
+async function resolveLocalDbChainId(appDb) {
+    const recorded = await readRecordedChainId(appDb);
+    if (recorded !== undefined)
+        return recorded;
+    if (await hasOnChainData(appDb)) {
+        await recordChainId(appDb, LEGACY_CHAIN_ID);
+        return LEGACY_CHAIN_ID;
+    }
+    return undefined;
+}
+/** How long EAS sync waits for `initPublish` to set the chain before using the current one. */
+const EAS_CHAIN_SETTLE_TIMEOUT_MS = 30000;
+/**
+ * Wait until the read chain is known before syncing. Only waits when `@seedprotocol/publish`
+ * is loaded but `initPublish` has not run, and no chain is configured or recorded locally.
+ */
+async function waitForEasReadChain(timeoutMs = EAS_CHAIN_SETTLE_TIMEOUT_MS) {
+    if (await whenEasReadChainSettled(timeoutMs))
+        return;
+    console.warn(`[Seed Protocol] EAS sync waited ${Math.round(timeoutMs / 1000)}s for initPublish to set the chain and is continuing on chain ${getEasReadChainId()}. Set SeedConfig.eas.chainId to skip the wait.`);
+}
+/**
+ * Called at SDK init once the DB is ready. Registers the DB's chain with the EAS read side so
+ * reads start on that chain even before publish is initialized, and throws when SeedConfig.eas
+ * or PublishConfig.chain names a different chain. An empty DB is recorded only when a chain
+ * is configured explicitly; otherwise the first sync or publish records it.
+ */
+async function loadLocalDbChain() {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const localChainId = await resolveLocalDbChainId(appDb);
+    if (localChainId !== undefined) {
+        configureEasReadChain('localDb', { chainId: localChainId });
+        logger$5('local DB holds chain %d', localChainId);
+        return;
+    }
+    if (isEasReadChainConfigured()) {
+        const chainId = getEasReadChainId();
+        await recordChainId(appDb, chainId);
+        configureEasReadChain('localDb', { chainId });
+    }
+}
+/**
+ * Call before writing chain data to the local DB (EAS sync, publish, revoke). Records the
+ * current chain on an empty DB; throws when the DB holds data from a different chain.
+ */
+async function assertLocalDbChain() {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const chainId = getEasReadChainId();
+    const localChainId = await resolveLocalDbChainId(appDb);
+    if (localChainId === undefined) {
+        await recordChainId(appDb, chainId);
+    }
+    // Throws with a remediation message when the local chain differs from the configured one.
+    configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
+}
+
 const logger$4 = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     logger$4('saveConfig starting');
@@ -9169,6 +9522,8 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                 await persistKey('gatewaySidecarPort', String(gatewaySidecarPort));
             }
             await persistKey('gatewayProxyBaseUrl', gatewayProxyBaseUrl);
+            // Throws when the DB holds attestations from a different chain than the one configured.
+            await loadLocalDbChain();
         }
         catch (error) {
             logger$4('[internal/actors] [saveConfig] Error saving config:', error);
@@ -9897,7 +10252,7 @@ function getRefValueType(prop) {
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const _mod_21 = await import('./BasePathResolver-qV0apdVY.js');
+    const _mod_21 = await import('./BasePathResolver-B6CKqoKw.js');
     const _ns_21 = _mod_21.M;
     const modelSchemaMod = _ns_21;
     const { properties: propertiesTable } = modelSchemaMod;
@@ -10245,8 +10600,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Check DB for existing schema by name+version (same as minimal path)
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_22 = await import('./BasePathResolver-qV0apdVY.js');
-            const _ns_22 = _mod_22.L;
+            const _mod_22 = await import('./BasePathResolver-B6CKqoKw.js');
+            const _ns_22 = _mod_22.O;
             const schemaSchemaMod = _ns_22;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -10329,8 +10684,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // For minimal imports: check DB for existing schema before creating new file
         const db = BaseDb.getAppDb();
         if (db) {
-            const _mod_23 = await import('./BasePathResolver-qV0apdVY.js');
-            const _ns_23 = _mod_23.L;
+            const _mod_23 = await import('./BasePathResolver-B6CKqoKw.js');
+            const _ns_23 = _mod_23.O;
             const schemaSchemaMod = _ns_23;
             const { schemas: schemasTable } = schemaSchemaMod;
             const drizzleMod = await import('drizzle-orm');
@@ -10508,8 +10863,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const _mod_24 = await import('./db-CceyWksv.js');
-        const _ns_24 = _mod_24.q;
+        const _mod_24 = await import('./db-WbrzEf7c.js');
+        const _ns_24 = _mod_24.Q;
         const dbMod = _ns_24;
         const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
@@ -10530,11 +10885,11 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     });
                     // Verify expected models are linked (single attempt - addModelsToDb already confirmed)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const _mod_25 = await import('./BasePathResolver-qV0apdVY.js');
-                    const _ns_25 = _mod_25.N;
+                    const _mod_25 = await import('./BasePathResolver-B6CKqoKw.js');
+                    const _ns_25 = _mod_25.Q;
                     const modelSchemaSchemaMod = _ns_25;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_26 = await import('./BasePathResolver-qV0apdVY.js');
+                    const _mod_26 = await import('./BasePathResolver-B6CKqoKw.js');
                     const _ns_26 = _mod_26.M;
                     const modelSchemaMod = _ns_26;
                     const { models: modelsTable } = modelSchemaMod;
@@ -10737,8 +11092,8 @@ async function applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, prope
         createdAt: new Date(schemaFile.metadata.createdAt).getTime(),
         updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
     };
-    const _mod_27 = await import('./db-CceyWksv.js');
-    const _ns_27 = _mod_27.q;
+    const _mod_27 = await import('./db-WbrzEf7c.js');
+    const _ns_27 = _mod_27.Q;
     const dbMod = _ns_27;
     const { addSchemaToDb, addModelsToDb } = dbMod;
     const db = BaseDb.getAppDb();
@@ -10897,11 +11252,11 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             if (db) {
                 const { schemaRecord } = await applySchemaToDb(schemaFile, modelDefinitions, modelFileIds, propertyFileIds);
                 // Query the database to get model IDs that were just created
-                const _mod_28 = await import('./BasePathResolver-qV0apdVY.js');
-                const _ns_28 = _mod_28.N;
+                const _mod_28 = await import('./BasePathResolver-B6CKqoKw.js');
+                const _ns_28 = _mod_28.Q;
                 const modelSchemaSchemaMod = _ns_28;
                 const { modelSchemas } = modelSchemaSchemaMod;
-                const _mod_29 = await import('./BasePathResolver-qV0apdVY.js');
+                const _mod_29 = await import('./BasePathResolver-B6CKqoKw.js');
                 const _ns_29 = _mod_29.M;
                 const modelSchemaMod = _ns_29;
                 const { models: modelsTable } = modelSchemaMod;
@@ -10967,7 +11322,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // After properties are created (file path), ensure schemaFile has the correct IDs from database
                 // Query the database to get the actual schemaFileId values that were used
                 // This ensures schemaData matches what's actually in the database
-                const _mod_30 = await import('./BasePathResolver-qV0apdVY.js');
+                const _mod_30 = await import('./BasePathResolver-B6CKqoKw.js');
                 const _ns_30 = _mod_30.M;
                 const modelSchemaMod2 = _ns_30;
                 const { properties: propertiesTable } = modelSchemaMod2;
@@ -11003,8 +11358,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // This is important even if nothing changed, to ensure consistency
                 const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                 // Update the schema record in the database with current schemaData
-                const _mod_31 = await import('./BasePathResolver-qV0apdVY.js');
-                const _ns_31 = _mod_31.L;
+                const _mod_31 = await import('./BasePathResolver-B6CKqoKw.js');
+                const _ns_31 = _mod_31.O;
                 const schemaSchemaMod = _ns_31;
                 const { schemas: schemasTable } = schemaSchemaMod;
                 await db
@@ -11046,7 +11401,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
  */
 const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
 propertyFileIds) => {
-    const _mod_32 = await import('./index-BFpbtEsg.js');
+    const _mod_32 = await import('./index-HRHkbVQd.js');
     const _ns_32 = _mod_32.b;
     const modelMod = _ns_32;
     const { Model } = modelMod;
@@ -12774,5 +13129,5 @@ var ClientManager$1 = /*#__PURE__*/Object.freeze({
     getClient: getClient
 });
 
-export { requestEasSyncFromEventBus as $, ADDRESSES_PERSISTED_EVENT as A, getClient as B, ClientManager as C, getGetPublisherForNewSeeds as D, getMetadataLatest as E, getPublishedSeedRecord as F, getRevokeExecutor as G, getSchemaNameFromId as H, Item as I, getUploadExecutor as J, getVersionData$1 as K, LOCAL_COPIES_REMOVED_EVENT as L, isItemOwned as M, isLocalUnsealedDraft as N, isSeedQueryLocalSourceRegistered as O, isSeedRowOwned as P, listCompleteSchemaFiles as Q, loadAllSchemasFromDb as R, mergeEasSyncRequestIntents as S, ownedPublisherSql as T, parseAddressesPersistedPayload as U, propertyMachine as V, publisherInAddressListSql as W, publisherIsInOwnedSet as X, readSchema as Y, registerSeedQueryLocalSource as Z, requestEasSyncFromAddressChange as _, getItemData as a, requestEasSyncFromModelsInit as a0, sendEasSyncClientRequest as a1, setAdditionalSyncAddresses as a2, setGetPublisherForNewSeeds as a3, setRevokeExecutor as a4, setUploadExecutor as a5, startEasSyncActor as a6, unregisterSeedQueryLocalSource as a7, getInvariantSafePropertyDescriptor as a8, unloadEntity as a9, clearDestroySubscriptions as aa, createModelsFromJson as ab, getLatestSchemaVersion as ac, createModelFromJson as ad, getPropertyData$1 as ae, Item$1 as af, schema as ag, SEEDPROTOCOL_Seed_Protocol_v1 as ah, ClientManager$1 as ai, getEasSchemaUidForModel as b, getLatestPublishedVersionRow as c, getEasSchemaForItemProperty as d, getGetAdditionalSyncAddresses as e, ItemProperty as f, getContentHash as g, getRefValueType as h, importJsonSchema as i, readJsonImportFile as j, createReactiveProxy as k, loadSchemaFromFile as l, findEntity as m, forceRemoveFromCaches as n, runDestroyLifecycle as o, parseListPropertyValueFromStorage as p, compareMetadataRowsLatestFirst as q, resolveStorageNameToSchemaName as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, claimUnpublishedDrafts as u, createLocalQueryDataSource as v, waitForEntityIdle as w, createNewItem as x, createSchema as y, easSyncActor as z };
-//# sourceMappingURL=ClientManager-Y5EWQuJj.js.map
+export { parseAddressesPersistedPayload as $, ADDRESSES_PERSISTED_EVENT as A, createLocalQueryDataSource as B, ClientManager as C, createNewItem as D, EAS_CHAIN_ID_APP_STATE_KEY as E, createSchema as F, easSyncActor as G, getClient as H, Item as I, getEasSchemaForItemProperty as J, getGetPublisherForNewSeeds as K, LOCAL_COPIES_REMOVED_EVENT as L, MachineIds as M, getMetadataLatest as N, getPublishedSeedRecord as O, getRevokeExecutor as P, getSchemaNameFromId as Q, getUploadExecutor as R, getVersionData$1 as S, isItemOwned as T, isLocalUnsealedDraft as U, isSeedQueryLocalSourceRegistered as V, isSeedRowOwned as W, listCompleteSchemaFiles as X, loadAllSchemasFromDb as Y, mergeEasSyncRequestIntents as Z, ownedPublisherSql as _, getItemData as a, propertyMachine as a0, publisherInAddressListSql as a1, publisherIsInOwnedSet as a2, readSchema as a3, registerSeedQueryLocalSource as a4, requestEasSyncFromAddressChange as a5, requestEasSyncFromEventBus as a6, requestEasSyncFromModelsInit as a7, sendEasSyncClientRequest as a8, setAdditionalSyncAddresses as a9, setGetPublisherForNewSeeds as aa, setRevokeExecutor as ab, setUploadExecutor as ac, startEasSyncActor as ad, unregisterSeedQueryLocalSource as ae, getInvariantSafePropertyDescriptor as af, unloadEntity as ag, clearDestroySubscriptions as ah, createModelsFromJson as ai, getLatestSchemaVersion as aj, createModelFromJson as ak, getPropertyData$1 as al, Item$1 as am, schema as an, SEEDPROTOCOL_Seed_Protocol_v1 as ao, ClientManager$1 as ap, getEasSchemaUidForModel as b, getLatestPublishedVersionRow as c, assertLocalDbChain as d, getGetAdditionalSyncAddresses as e, ItemProperty as f, getContentHash as g, ItemPropertySaveValidationError as h, getRefValueType as i, importJsonSchema as j, loadSchemaFromFile as k, listRelationEasPropertyName as l, readJsonImportFile as m, waitForEntityIdle as n, createReactiveProxy as o, parseListPropertyValueFromStorage as p, findEntity as q, resolveStorageNameToSchemaName as r, syncSchemaFromSource as s, transformImportToSchemaFile as t, forceRemoveFromCaches as u, runDestroyLifecycle as v, waitForEasReadChain as w, compareMetadataRowsLatestFirst as x, ClientManagerState as y, claimUnpublishedDrafts as z };
+//# sourceMappingURL=ClientManager-ChcmUL47.js.map