@seedprotocol/sdk 0.6.7 → 0.6.8

package/dist/cjs/{index-DM1WR83P.js → index-CSNtEnbF.js}

@@ -21,6 +21,7 @@ var utils = require('@noble/hashes/utils');
 var fsAsync = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
+var url = require('url');
 var node_url = require('node:url');
 var client = require('@libsql/client');
 var libsql = require('drizzle-orm/libsql');
@@ -204,17 +205,19 @@ class BaseFileManager {
     static getContentUrlFromPath(path) {
         return BaseFileManager.requireImpl().getContentUrlFromPath(path);
     }
-    static downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions, }) {
+    static downloadAllFiles({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions, }) {
         return BaseFileManager.requireImpl().downloadAllFiles({
             transactionIds,
             arweaveHost,
+            arweaveBaseUrls,
             excludedTransactions,
         });
     }
-    static downloadFileByTransactionId({ transactionId, arweaveHost, excludedTransactions, }) {
+    static downloadFileByTransactionId({ transactionId, arweaveHost, arweaveBaseUrls, excludedTransactions, }) {
         return BaseFileManager.requireImpl().downloadAllFiles({
             transactionIds: [transactionId],
             arweaveHost,
+            arweaveBaseUrls,
             excludedTransactions,
         });
     }
@@ -429,6 +432,50 @@ function normalizeDataType(value) {
     const lower = value.toLowerCase().trim();
     return DATA_TYPE_LOWER_MAP[lower] ?? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
 }
+/**
+ * Case-insensitive dataType check. Use instead of `dataType === 'List'` so schemas
+ * (or existing DB rows) with lowercase types like "list" still match.
+ */
+function isDataType(value, expected) {
+    if (!value)
+        return false;
+    return normalizeDataType(value) === expected;
+}
+/**
+ * Normalize a property definition to the internal shape ItemProperty reads (`dataType`,
+ * `refValueType`, `ref`, `storageType`, ...). Accepts schema-file shape (`type`, `model`,
+ * `items`, `storage`) and any casing. Mirrors the conversion in imports/json createModelFromJson
+ * for the fallback paths that read schema-file properties directly.
+ */
+function normalizePropertyRecordSchema(def) {
+    if (!def || typeof def !== 'object')
+        return def;
+    const src = def;
+    const out = { ...src };
+    const rawType = src.dataType ?? src.type;
+    if (typeof rawType === 'string' && rawType)
+        out.dataType = normalizeDataType(rawType);
+    const ref = src.ref ?? src.refModelName ?? src.items?.model ?? src.model;
+    if (ref && !out.ref)
+        out.ref = ref;
+    if (ref && !out.refModelName)
+        out.refModelName = ref;
+    const rawRefValueType = src.refValueType ?? src.items?.type;
+    if (typeof rawRefValueType === 'string' && rawRefValueType) {
+        out.refValueType = normalizeDataType(rawRefValueType);
+    }
+    else if (out.dataType === exports.ModelPropertyDataTypes.List && ref) {
+        out.refValueType = exports.ModelPropertyDataTypes.Relation;
+    }
+    if (src.storage && typeof src.storage === 'object' && !out.storageType) {
+        out.storageType = src.storage.type === 'ItemStorage' ? 'ItemStorage' : 'PropertyStorage';
+        if (src.storage.path !== undefined && out.localStorageDir === undefined)
+            out.localStorageDir = src.storage.path;
+        if (src.storage.extension !== undefined && out.filenameSuffix === undefined)
+            out.filenameSuffix = src.storage.extension;
+    }
+    return out;
+}
 const TPropertyDataType = typebox.Type.Union([
     typebox.Type.Literal(exports.ModelPropertyDataTypes.Text),
     typebox.Type.Literal(exports.ModelPropertyDataTypes.Number),
@@ -538,20 +585,34 @@ const Boolean$1 = () => PropertyConstructor(Property.Boolean());
 const Date$1 = () => PropertyConstructor(Property.Date());
 const Html = (opts) => PropertyConstructor(htmlPropertyFactory(opts));
 
-/**
- * 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`.
@@ -668,6 +729,73 @@ function resolveMetadataRecord(records, preferredPropertyName, dataType, refValu
     return (records.find((r) => r.propertyName === preferredPropertyName) ?? records[0]);
 }
 
+/** Same rules as getCorrectId in helpers/index (avoid barrel circular import). */
+function parseLocalIdOrUid(localIdOrUid) {
+    const id = { localId: undefined, uid: undefined };
+    if (!localIdOrUid)
+        return id;
+    if (localIdOrUid.length === 10) {
+        id.localId = localIdOrUid;
+    }
+    if (localIdOrUid.startsWith('0x') && localIdOrUid.length === 66) {
+        id.uid = localIdOrUid;
+    }
+    return id;
+}
+/** Relation/image refs may be string ids or `{ seedLocalId?, seedUid? }`. */
+function normalizeRelationPropertyValue(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string') {
+        const t = value.trim();
+        return t !== '' ? t : undefined;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const o = value;
+        if (typeof o.seedLocalId === 'string' && o.seedLocalId.trim() !== '') {
+            return o.seedLocalId.trim();
+        }
+        if (typeof o.seedUid === 'string' && o.seedUid.trim() !== '') {
+            return o.seedUid.trim();
+        }
+    }
+    return undefined;
+}
+/** getCorrectId only accepts 10-char local ids and 0x66 uids; local seed refs can be up to 21 chars. */
+const LOCAL_SEED_REF = /^[a-zA-Z0-9_-]{10,21}$/;
+/** Resolve seed ids from a single string (context propertyValue or DB row). */
+function resolveSeedIdsFromRefString(s) {
+    const fromCorrect = parseLocalIdOrUid(s);
+    if (fromCorrect.localId || fromCorrect.uid) {
+        return { seedLocalId: fromCorrect.localId, seedUid: fromCorrect.uid };
+    }
+    if (LOCAL_SEED_REF.test(s) && !s.startsWith('0x')) {
+        return { seedLocalId: s };
+    }
+    return {};
+}
+/**
+ * True when a relation ref is an attested seed uid (0x…) rather than a local id. A uid only exists once
+ * the seed is on EAS, so publish can attest the uid as-is when no local copy exists (e.g. a server
+ * publishing on someone's behalf that only holds the uids it was given). Callers must not walk into it.
+ */
+function isPublishedSeedRef(value) {
+    const ref = normalizeRelationPropertyValue(value);
+    if (!ref)
+        return false;
+    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
+    return !!seedUid && !seedLocalId;
+}
+/**
+ * Storage seed local id (nanoid) or 0x uid. Stricter than resolveSeedIdsFromRefString, which accepts
+ * any 10-char string (so a 10-char html snippet like "<p>raw</p>" would pass as a local id).
+ */
+const STORAGE_SEED_REF = /^(?:[A-Za-z0-9_-]{10,21}|0x[0-9a-fA-F]{64})$/;
+/** True when a File/Image/Html value is already a storage seed reference rather than raw content. */
+function isStorageSeedRef(value) {
+    return typeof value === 'string' && STORAGE_SEED_REF.test(value.trim());
+}
+
 const seeds = sqliteCore.sqliteTable('seeds', {
     localId: sqliteCore.text('local_id').unique(),
     uid: sqliteCore.text('uid'),
@@ -805,6 +933,7 @@ const publishProcesses = sqliteCore.sqliteTable('publish_processes', {
     errorMessage: sqliteCore.text('error_message'),
     errorStep: sqliteCore.text('error_step'),
     errorDetails: sqliteCore.text('error_details'),
+    errorCode: sqliteCore.text('error_code'), // e.g. ManagedAccountPublishError.code
     persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(),
     seedId: sqliteCore.text('seed_id'),
     existingSeedUid: sqliteCore.text('existing_seed_uid'),
@@ -1072,7 +1201,52 @@ function normalizeAddressConfig(addresses) {
     };
 }
 
-const logger$x = debug('seedSdk:helpers:db');
+/**
+ * Convert Model.properties array to object format (for backward compatibility)
+ * This replaces the old model.schema getter
+ */
+function modelPropertiesToObject(properties) {
+    const schemaObj = {};
+    for (const property of properties) {
+        const propContext = property._getSnapshotContext();
+        if (propContext.name) {
+            schemaObj[propContext.name] = {
+                dataType: propContext.dataType,
+                ref: propContext.refModelName || propContext.ref,
+                refValueType: propContext.refValueType,
+                storageType: propContext.storageType,
+                localStorageDir: propContext.localStorageDir,
+                filenameSuffix: propContext.filenameSuffix,
+                required: propContext.required,
+            };
+        }
+    }
+    return schemaObj;
+}
+
+var model = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    modelPropertiesToObject: modelPropertiesToObject
+});
+
+const logger$y = debug('seedSdk:helpers:db');
+/**
+ * Resolve property_id (integer properties.id) from a property's schemaFileId (the string `id` in
+ * schema files and propertyRecordSchema). Scoped to the model since schemaFileIds are per schema file.
+ * @returns properties.id or null if not found
+ */
+async function getPropertyIdForSchemaFileId(modelNameOrType, schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db || !modelNameOrType || !schemaFileId)
+        return null;
+    const rows = await db
+        .select({ id: properties.id })
+        .from(properties)
+        .innerJoin(models$1, drizzleOrm.eq(properties.modelId, models$1.id))
+        .where(drizzleOrm.and(drizzleOrm.eq(models$1.name, lodashEs.upperFirst(lodashEs.camelCase(modelNameOrType))), drizzleOrm.eq(properties.schemaFileId, schemaFileId)))
+        .limit(1);
+    return rows[0]?.id ?? null;
+}
 /**
  * Resolve property_id from model name/type and property name.
  * Handles property name variants (e.g. htmlId -> html, avatarImageIds -> avatarImages).
@@ -1120,28 +1294,19 @@ async function getPropertyIdForModelAndName(modelNameOrType, propertyName) {
 async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId) {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger$x('[migrateMetadataForPropertyRename] Database not available, skipping');
+        logger$y('[migrateMetadataForPropertyRename] Database not available, skipping');
         return 0;
     }
-    const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(modelName));
     // Find the property row by schemaFileId (preferred) or by name
     let propertyId = null;
     if (propertySchemaFileId) {
-        const rows = await db
-            .select({ id: properties.id })
-            .from(properties)
-            .innerJoin(models$1, drizzleOrm.eq(properties.modelId, models$1.id))
-            .where(drizzleOrm.and(drizzleOrm.eq(models$1.name, normalizedModelName), drizzleOrm.eq(properties.schemaFileId, propertySchemaFileId)))
-            .limit(1);
-        if (rows.length > 0 && rows[0].id != null) {
-            propertyId = rows[0].id;
-        }
+        propertyId = await getPropertyIdForSchemaFileId(modelName, propertySchemaFileId);
     }
     if (propertyId == null) {
         propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName);
     }
     if (propertyId == null) {
-        logger$x(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
+        logger$y(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
         return 0;
     }
     // Primary path: update metadata by propertyId
@@ -1170,11 +1335,11 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
             .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.propertyName, oldPropertyName), drizzleOrm.eq(metadata$1.modelType, modelType), drizzleOrm.isNull(metadata$1.propertyId)));
     }
     if (updatedByFallback > 0) {
-        logger$x(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
+        logger$y(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
     }
     const total = updatedByPropertyId + updatedByFallback;
     if (total > 0) {
-        logger$x(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
+        logger$y(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
     }
     return total;
 }
@@ -1274,7 +1439,7 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId) => {
                     .set({ schemaFileId: modelFileId, isEdited: false })
                     .where(drizzleOrm.eq(models$1.id, chosen.id));
                 chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
-                logger$x(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+                logger$y(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
             }
         }
         return chosen;
@@ -1521,7 +1686,7 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             .limit(1);
         if (draftSchemas.length > 0) {
             // Found a draft - we'll update it to non-draft below
-            logger$x(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
+            logger$y(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
             existingSchemas = draftSchemas;
         }
     }
@@ -1541,11 +1706,11 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
                 !existingSchemas[0].schemaFileId ||
                 (isDraft === false && existingSchemas[0].isDraft === true);
             if (shouldUpdate) {
-                logger$x(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
+                logger$y(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
                 updates.schemaFileId = schemaFileId;
             }
             else {
-                logger$x(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
+                logger$y(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
             }
         }
         // Always update name if it's different (handles name changes)
@@ -1572,16 +1737,16 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             updates.updatedAt = schema.updatedAt;
         }
         if (Object.keys(updates).length > 0) {
-            logger$x(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
+            logger$y(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
             await db
                 .update(schemas)
                 .set(updates)
                 .where(drizzleOrm.eq(schemas.id, existingSchemas[0].id));
             const updated = { ...existingSchemas[0], ...updates };
-            logger$x(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
+            logger$y(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
             return updated;
         }
-        logger$x(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
+        logger$y(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
         return existingSchemas[0];
     }
     const newSchema = await db.insert(schemas).values({
@@ -1762,7 +1927,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
                         // Compare database value with schema file value
                         // If they differ, the property has been edited
                         if (dbProperty.dataType !== schemaFileValue.dataType) {
-                            logger$x(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
+                            logger$y(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
                             return true;
                         }
                         // Check refModelId if it's a relation
@@ -1775,19 +1940,19 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
                             if (refModelRecords.length > 0) {
                                 const expectedRefModelId = refModelRecords[0].id;
                                 if (dbProperty.refModelId !== expectedRefModelId) {
-                                    logger$x(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                                    logger$y(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                                     return true;
                                 }
                             }
                         }
                         else if (dbProperty.refModelId !== null) {
                             // Schema file has no ref, but DB has one
-                            logger$x(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                            logger$y(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                             return true;
                         }
                         // Check refValueType
                         if (dbProperty.refValueType !== (schemaFileValue.refValueType || null)) {
-                            logger$x(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
+                            logger$y(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
                             return true;
                         }
                         // Check required (for Relation/Image properties)
@@ -1795,7 +1960,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
                             const schemaRequired = !!schemaFileValue.required;
                             const dbRequired = dbProperty.required === true;
                             if (dbRequired !== schemaRequired) {
-                                logger$x(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
+                                logger$y(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
                                 return true;
                             }
                         }
@@ -1807,7 +1972,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
     }
     catch (error) {
         // If we can't check, assume it's not edited to be safe
-        logger$x('Error checking if property is edited:', error);
+        logger$y('Error checking if property is edited:', error);
         return false;
     }
 }
@@ -1832,11 +1997,11 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
         // SchemaType includes id, so check if it's set
         if (schema.id !== null && schema.id !== undefined) {
             schemaRecord = schema;
-            logger$x(`Using existing schema record with id: ${schemaRecord.id}`);
+            logger$y(`Using existing schema record with id: ${schemaRecord.id}`);
         }
         else {
             schemaRecord = await addSchemaToDb(schema, schemaFileData?.schemaFileId);
-            logger$x(`Created/found schema record with id: ${schemaRecord.id}`);
+            logger$y(`Created/found schema record with id: ${schemaRecord.id}`);
         }
     }
     // Handle model renames first if provided
@@ -1862,7 +2027,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                     .where(drizzleOrm.eq(models$1.schemaFileId, modelFileId))
                     .limit(1);
                 if (existingWithFileId.length > 0 && existingWithFileId[0].id !== modelRecord.id) {
-                    logger$x(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
+                    logger$y(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
                     modelRecord = existingWithFileId[0];
                 }
                 else if (!modelRecord.schemaFileId) {
@@ -1920,7 +2085,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 if (!propertyFileId) {
                     const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                     propertyFileId = generateId();
-                    logger$x(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
+                    logger$y(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
                 }
                 // First, try to find by schemaFileId (preferred for change tracking)
                 let existingProperty;
@@ -1935,7 +2100,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 const propertyData = {
                     name: propertyName,
                     modelId: modelRecord.id,
-                    dataType: propertyValues.dataType,
+                    dataType: normalizeDataType(propertyValues.dataType),
                     schemaFileId: propertyFileId || null,
                     required: propertyValues.required ?? false,
                 };
@@ -1961,7 +2126,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                     propertyData.refModelId = null;
                 }
                 if (propertyValues.refValueType) {
-                    propertyData.refValueType = propertyValues.refValueType;
+                    propertyData.refValueType = normalizeDataType(propertyValues.refValueType);
                 }
                 else {
                     // If refValueType is not set, ensure it's null
@@ -1985,7 +2150,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                     if (potentialMatches.length > 0) {
                         const matchedProperty = potentialMatches[0];
                         existingProperty = matchedProperty;
-                        logger$x(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
+                        logger$y(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
                     }
                 }
                 if (existingProperty) {
@@ -2005,7 +2170,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                         });
                     if (isPropertyEdited) {
                         // Property has been locally edited - skip update to preserve local changes
-                        logger$x(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
+                        logger$y(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
                         continue;
                     }
                     // Property exists (possibly with different name) - update it with new values from schema file
@@ -2053,18 +2218,18 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                         if (existingByFileId.length > 0) {
                             const found = existingByFileId[0];
                             matchedDbPropertyIds.add(found.id);
-                            logger$x(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
+                            logger$y(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
                             continue;
                         }
                     }
-                    logger$x(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
+                    logger$y(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
                     try {
                         await db.insert(properties).values(propertyDataWithIsEdited);
                     }
                     catch (insertError) {
                         // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb call)
                         if (isSqliteUniqueConstraintError(insertError)) {
-                            logger$x(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
+                            logger$y(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
                         }
                         else {
                             throw insertError;
@@ -2075,14 +2240,14 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
         }
         catch (error) {
             const errorMessage = error?.message || String(error);
-            logger$x(`Error processing model "${modelName}": ${errorMessage}`);
+            logger$y(`Error processing model "${modelName}": ${errorMessage}`);
             modelProcessingErrors.push({ modelName, error: errorMessage });
             // Continue processing other models even if one fails
         }
     }
     if (modelProcessingErrors.length > 0) {
         console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
-        logger$x(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
+        logger$y(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
     }
     // If schema was provided, create modelSchema join records to connect models to the schema
     if (schemaRecord && schemaRecord.id) {
@@ -2090,7 +2255,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
             .filter(([, r]) => r.id)
             .map(([name, r]) => ({ modelName: name, modelId: r.id }));
         if (modelIds.length === 0) {
-            logger$x('No model IDs to link, skipping schema linking');
+            logger$y('No model IDs to link, skipping schema linking');
         }
         else {
             // Single batch query: get all existing joins for this schema
@@ -2106,13 +2271,13 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                         modelId,
                         schemaId: schemaRecord.id,
                     });
-                    logger$x(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
+                    logger$y(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
                 }
             }
         }
     }
     else if (schemaRecord && !schemaRecord.id) {
-        logger$x(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
+        logger$y(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
     }
 };
 /**
@@ -2125,7 +2290,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
 const loadModelsFromDbForSchema = async (schemaId) => {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger$x('Database not found, cannot load models from DB');
+        logger$y('Database not found, cannot load models from DB');
         return {};
     }
     try {
@@ -2156,7 +2321,7 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 // Note: This is a simplified reconstruction - full property schemas
                 // (like Relation details, List configs, etc.) should come from schemaData
                 const propertyData = {
-                    dataType: prop.dataType,
+                    dataType: normalizeDataType(prop.dataType ?? undefined),
                 };
                 if (prop.schemaFileId) {
                     propertyData.schemaFileId = prop.schemaFileId;
@@ -2174,7 +2339,7 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                     }
                 }
                 if (prop.refValueType) {
-                    propertyData.refValueType = prop.refValueType;
+                    propertyData.refValueType = normalizeDataType(prop.refValueType ?? undefined);
                 }
                 modelProperties[prop.name] = propertyData;
             }
@@ -2188,11 +2353,11 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 // or reconstructed from schemaData if available
             };
         }
-        logger$x(`Loaded ${Object.keys(models).length} models from database for schema ${schemaId}`);
+        logger$y(`Loaded ${Object.keys(models).length} models from database for schema ${schemaId}`);
         return models;
     }
     catch (error) {
-        logger$x(`Error loading models from database for schema ${schemaId}:`, error);
+        logger$y(`Error loading models from database for schema ${schemaId}:`, error);
         return {};
     }
 };
@@ -2313,40 +2478,40 @@ const savePropertyToDb = async (property) => {
     // Find existing property - try multiple strategies to handle name changes
     // 1. First try by schemaFileId (most reliable - doesn't change when name changes)
     let existingProperties = [];
-    logger$x(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
+    logger$y(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
     if (schemaFileId) {
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.schemaFileId, schemaFileId), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$x(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
+        logger$y(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
     }
     // 2. If not found by schemaFileId, try by original name (if name was changed)
     if (existingProperties.length === 0 && property._originalValues?.name && property._originalValues.name !== property.name) {
-        logger$x(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
+        logger$y(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.name, property._originalValues.name), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$x(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
+        logger$y(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
     }
     // 3. Fallback: try by current name
     if (existingProperties.length === 0) {
-        logger$x(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
+        logger$y(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.name, property.name), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$x(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
+        logger$y(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
     }
     // Prepare property data
     const propertyData = {
         name: property.name,
         modelId: modelRecord.id,
-        dataType: property.dataType || '',
+        dataType: normalizeDataType(property.dataType),
     };
     // Preserve schemaFileId if we have it
     if (schemaFileId) {
@@ -2367,7 +2532,7 @@ const savePropertyToDb = async (property) => {
         propertyData.refModelId = null;
     }
     if (property.refValueType) {
-        propertyData.refValueType = property.refValueType;
+        propertyData.refValueType = normalizeDataType(property.refValueType);
     }
     else {
         // If refValueType is not set, ensure it's null
@@ -2385,7 +2550,7 @@ const savePropertyToDb = async (property) => {
             isEdited: true, // Mark as edited when saving changes
         })
             .where(drizzleOrm.eq(properties.id, existingProperty.id));
-        logger$x(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
+        logger$y(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -2395,12 +2560,12 @@ const savePropertyToDb = async (property) => {
                 ...propertyData,
                 isEdited: true, // Runtime-created properties are edited
             });
-            logger$x(`Created property ${property.modelName}:${property.name} in database`);
+            logger$y(`Created property ${property.modelName}:${property.name} in database`);
         }
         catch (insertError) {
             // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb or race)
             if (isSqliteUniqueConstraintError(insertError)) {
-                logger$x(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
+                logger$y(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
             }
             else {
                 throw insertError;
@@ -2517,7 +2682,7 @@ async function writeModelToDb(modelFileId, data) {
         if (doubleCheck.length > 0) {
             // Another process created it, use existing
             modelId = doubleCheck[0].id;
-            logger$x(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
+            logger$y(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
         }
         else {
             try {
@@ -2531,7 +2696,7 @@ async function writeModelToDb(modelFileId, data) {
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger$x(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
+                    logger$y(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
                     const existing = await db
                         .select()
                         .from(models$1)
@@ -2539,7 +2704,7 @@ async function writeModelToDb(modelFileId, data) {
                         .limit(1);
                     if (existing.length > 0) {
                         modelId = existing[0].id;
-                        logger$x(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
+                        logger$y(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
                     }
                     else {
                         throw error;
@@ -2609,7 +2774,7 @@ async function writeModelToDb(modelFileId, data) {
             if (schemaCheck.length === 0) {
                 throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
             }
-            logger$x(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
+            logger$y(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
             await db.insert(modelSchemas).values({
                 modelId,
                 schemaId: data.schemaId,
@@ -2627,13 +2792,13 @@ async function writeModelToDb(modelFileId, data) {
                 }
                 catch (_) { }
             }
-            logger$x(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
+            logger$y(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
         }
         catch (error) {
             if (error?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
-                logger$x(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
-                logger$x(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
-                logger$x(`Error details:`, error);
+                logger$y(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
+                logger$y(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
+                logger$y(`Error details:`, error);
                 // Re-throw with more context
                 throw new Error(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}" (modelId: ${modelId}, schemaId: ${data.schemaId}). ${error.message}`);
             }
@@ -2653,7 +2818,7 @@ async function writeModelToDb(modelFileId, data) {
             if (existingProps.length > 0 && existingProps[0].schemaFileId) {
                 // Use existing property's schemaFileId
                 propertyFileId = existingProps[0].schemaFileId;
-                logger$x(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$y(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             else if (propData.id) {
                 // Use provided ID
@@ -2664,7 +2829,7 @@ async function writeModelToDb(modelFileId, data) {
                 // IDs should be generated in the import process before calling writeModelToDb
                 const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                 propertyFileId = generateId();
-                logger$x(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$y(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             await writePropertyToDb(propertyFileId, {
                 modelId,
@@ -2673,7 +2838,7 @@ async function writeModelToDb(modelFileId, data) {
             });
         }
     }
-    logger$x(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+    logger$y(`Wrote model ${data.modelName} (${modelFileId}) to database`);
 }
 /**
  * Write property to database
@@ -2703,7 +2868,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
     const propertyData = {
         name: data.name,
         modelId: data.modelId,
-        dataType: data.dataType || '',
+        dataType: normalizeDataType(data.dataType),
         schemaFileId: propertyFileId,
         isEdited: isEdited, // Persist isEdited flag
     };
@@ -2724,7 +2889,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         propertyData.refModelId = null;
     }
     if (data.refValueType) {
-        propertyData.refValueType = data.refValueType;
+        propertyData.refValueType = normalizeDataType(data.refValueType);
     }
     else {
         // If refValueType is not set, ensure it's null
@@ -2742,7 +2907,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
             .update(properties)
             .set(propertyData)
             .where(drizzleOrm.eq(properties.id, existing.id));
-        logger$x(`Updated property ${data.name} (${propertyFileId}) in database`);
+        logger$y(`Updated property ${data.name} (${propertyFileId}) in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -2758,17 +2923,17 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                 .update(properties)
                 .set(propertyData)
                 .where(drizzleOrm.eq(properties.id, doubleCheck[0].id));
-            logger$x(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
+            logger$y(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
         }
         else {
             try {
                 await db.insert(properties).values(propertyData);
-                logger$x(`Created property ${data.name} (${propertyFileId}) in database`);
+                logger$y(`Created property ${data.name} (${propertyFileId}) in database`);
             }
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger$x(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
+                    logger$y(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
                     const existing = await db
                         .select()
                         .from(properties)
@@ -2779,7 +2944,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                             .update(properties)
                             .set(propertyData)
                             .where(drizzleOrm.eq(properties.id, existing[0].id));
-                        logger$x(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
+                        logger$y(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
                     }
                     else {
                         throw new Error(`Failed to create or find property "${data.name}" with schemaFileId "${propertyFileId}": ${error.message}`);
@@ -2962,6 +3127,7 @@ var db = /*#__PURE__*/Object.freeze({
     getObjectForRow: getObjectForRow,
     getOwnedAddressesFromDb: getOwnedAddressesFromDb,
     getPropertyIdForModelAndName: getPropertyIdForModelAndName,
+    getPropertyIdForSchemaFileId: getPropertyIdForSchemaFileId,
     getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
     getSchemaId: getSchemaId,
     getSchemaIdByFileId: getSchemaIdByFileId,
@@ -3053,7 +3219,7 @@ const supportsOpfsFileDownloads = () => {
     return isBrowser() || isElectronRenderer();
 };
 
-const logger$w = debug('seedSdk:files:download');
+const logger$x = debug('seedSdk:files:download');
 const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
 /** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
 const GET_FILES_METADATA_STALE_MS = 120000;
@@ -3063,7 +3229,7 @@ const lazyDownloadInFlightByTransactionId = new Map();
 const syncDbFiles = async (endpoints) => {
     // TODO: Implement syncDbFiles functionality if needed
     // This was previously in @/services/internal/helpers
-    logger$w('[download] syncDbFiles called but not yet implemented');
+    logger$x('[download] syncDbFiles called but not yet implemented');
     return Promise.resolve();
 };
 const getAppDbReady = async () => {
@@ -3249,16 +3415,19 @@ const downloadTransactionIds = async (rawTransactionIds, options) => {
             transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
-            logger$w(error);
+            logger$x(error);
         }
     }
     if (transactionIdsToDownload.length === 0) {
         return false;
     }
+    // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
+    const arweaveBaseUrls = arweave.getArweaveReadBaseUrls();
     if (transactionIdsToDownload.length === 1) {
         await BaseFileManager.downloadFileByTransactionId({
             transactionId: transactionIdsToDownload[0],
             arweaveHost: arweave.BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
             excludedTransactions,
         });
     }
@@ -3266,6 +3435,7 @@ const downloadTransactionIds = async (rawTransactionIds, options) => {
         await BaseFileManager.downloadAllFiles({
             transactionIds: transactionIdsToDownload,
             arweaveHost: arweave.BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
             excludedTransactions,
         });
     }
@@ -3382,7 +3552,7 @@ const downloadTransactionIdWithDedupe = async (transactionId) => {
 };
 const scheduleBulkFilesDownloadFromEasSyncThrottled = lodashEs.throttle((addressesHint) => {
     void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
-        logger$w('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+        logger$x('[scheduleBulkFilesDownloadFromEasSync] failed', error);
     });
 }, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
 const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
@@ -3483,7 +3653,11 @@ const INTERNAL_PROPERTY_NAMES = [
     // SDK-internal: Unix timestamp when attestations were revoked; never a schema field
     'revokedAt',
 ];
-const VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA = '0x13c0fd59d69dbce40501a41f8b37768d26dd2e2bb0cad64615334d84f7b9bdf6';
+/**
+ * UID of {@link VERSION_SCHEMA_DEF}. Schema UIDs hash the definition, resolver and revocable flag,
+ * so this is the same on every chain; the schema must still be registered on each one.
+ */
+const VERSION_SCHEMA_UID = '0x13c0fd59d69dbce40501a41f8b37768d26dd2e2bb0cad64615334d84f7b9bdf6';
 const defaultAttestationData = {
     recipient: ZERO_ADDRESS,
     revocable: true,
@@ -3521,7 +3695,7 @@ function isInternalSchema(schemaName, schemaId) {
         (schemaId !== undefined && INTERNAL_SCHEMA_IDS.includes(schemaId));
 }
 
-const logger$v = debug('seedSdk:helpers:ensureImageLocal');
+const logger$w = debug('seedSdk:helpers:ensureImageLocal');
 /** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
 const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
 const IMAGE_SIZES = [
@@ -3690,7 +3864,7 @@ const runEnsureImageLocal = async (params) => {
         };
     }
     catch (error) {
-        logger$v('ensureImageLocal failed', error);
+        logger$w('ensureImageLocal failed', error);
         return { status: 'failed' };
     }
 };
@@ -3739,7 +3913,7 @@ var generateId$1 = /*#__PURE__*/Object.freeze({
     generateId: generateId
 });
 
-const logger$u = debug('seedSdk:shared:helpers');
+const logger$v = debug('seedSdk:shared:helpers');
 const toSnakeCase = (str) => {
     return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
 };
@@ -3796,7 +3970,7 @@ const convertTxIdToImage = async (txId) => {
     const imageFilePath = BaseFileManager.getFilesPath('images', txId);
     const fileExists = await BaseFileManager.pathExists(imageFilePath);
     if (!fileExists) {
-        logger$u(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
+        logger$v(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
         return;
     }
     const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
@@ -3825,7 +3999,7 @@ const convertTxIdToImage = async (txId) => {
     return URL.createObjectURL(imageBlob);
 };
 
-const logger$t = debug('seedSdk:model:actors:loadOrCreateModel');
+const logger$u = debug('seedSdk:model:actors:loadOrCreateModel');
 /**
  * Create ModelProperty instances for all property IDs to ensure they're cached
  * This ensures that ModelProperty.getById() in Model.properties getter will find the instances
@@ -3836,10 +4010,10 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CDTOx5zi.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
-            logger$t('createPropertyInstances: ModelProperty not available from dynamic import');
+            logger$u('createPropertyInstances: ModelProperty not available from dynamic import');
             return;
         }
         // Create instances for all property IDs in parallel
@@ -3848,22 +4022,22 @@ const createPropertyInstances = async (propertyFileIds) => {
             try {
                 const property = await ModelProperty.createById(propertyFileId);
                 if (property) {
-                    logger$t(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
+                    logger$u(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
                 }
                 else {
-                    logger$t(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
+                    logger$u(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
                 }
             }
             catch (error) {
-                logger$t(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                logger$u(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                 // Don't throw - continue with other properties
             }
         });
         await Promise.all(createPromises);
-        logger$t(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
+        logger$u(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
     }
     catch (error) {
-        logger$t(`Error in createPropertyInstances: ${error}`);
+        logger$u(`Error in createPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
 };
@@ -3893,7 +4067,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                     if (dbModels.length > 0) {
                         modelRecord = dbModels[0];
                         foundBySchemaFileId = true;
-                        logger$t(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
+                        logger$u(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
                     }
                 }
                 // If not found by ID, try by name
@@ -3920,16 +4094,16 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                 // Access instanceCacheById via type assertion since it's protected
                                 const cacheById = Model.instanceCacheById;
                                 if (cacheById.has(dbSchemaFileId)) {
-                                    logger$t(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
+                                    logger$u(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
                                     // Update the current instance's schemaFileId to match the database
                                     // This ensures both instances point to the same cached instance
                                     modelRecord = foundModel;
                                     schemaFileId = dbSchemaFileId;
-                                    logger$t(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
+                                    logger$u(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
                                 }
                             }
                             catch (error) {
-                                logger$t(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
+                                logger$u(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
                                 // Fall through to normal processing
                             }
                         }
@@ -3937,31 +4111,31 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                         // this is a new model - don't use the existing model (will be renamed if duplicate)
                         // UNLESS we found a cached instance above (in which case modelRecord is already set)
                         if (!modelRecord && schemaFileId && dbSchemaFileId && schemaFileId !== dbSchemaFileId) {
-                            logger$t(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
+                            logger$u(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
                             // Don't set modelRecord - we'll create a new model with potentially renamed name
                         }
                         else if (!modelRecord && schemaFileId && !dbSchemaFileId) {
                             // We have a schemaFileId but the found model doesn't have one - this is a new model
                             // Don't reuse the existing model, create a new one (will be renamed if duplicate)
-                            logger$t(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
+                            logger$u(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
                             // Don't set modelRecord - we'll create a new model
                         }
                         else if (!modelRecord) {
                             // Only reuse existing model if:
                             // 1. No schemaFileId was provided (loading existing model), OR
                             // 2. schemaFileId matches (same model)
-                            logger$t(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
+                            logger$u(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
                             modelRecord = foundModel;
                             // Only use database schemaFileId if no id was explicitly provided
                             // If an id was provided, we should use it (it might be creating a new model with a specific ID)
                             if (!id && dbSchemaFileId) {
                                 schemaFileId = dbSchemaFileId;
-                                logger$t(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
+                                logger$u(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
                             }
                             else if (id) {
-                                logger$t(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
+                                logger$u(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
                             }
-                            logger$t(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
+                            logger$u(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
                         }
                     }
                 }
@@ -3984,7 +4158,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                     // Generate schemaFileId if not set
                     if (!schemaFileId) {
                         schemaFileId = generateId();
-                        logger$t(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                        logger$u(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                     }
                     // Include _dbId from database record so properties can be created if needed
                     // Even if we found an existing model, we may still need to create properties
@@ -4013,14 +4187,14 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                 }
             }
             catch (error) {
-                logger$t(`Error loading model from database: ${error}`);
+                logger$u(`Error loading model from database: ${error}`);
                 // Fall through to create new model
             }
         }
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -4048,10 +4222,10 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                 const byName = schemaContext.models[modelName];
                 const schemaModelId = byName?.id ?? null;
                 if (schemaFileId === schemaModelId) {
-                    logger$t(`Found model "${modelName}" in Schema context (database fallback)`);
+                    logger$u(`Found model "${modelName}" in Schema context (database fallback)`);
                     if (!schemaFileId) {
                         schemaFileId = generateId();
-                        logger$t(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                        logger$u(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                     }
                     sendBack({
                         type: 'loadOrCreateModelSuccess',
@@ -4067,7 +4241,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                     // Schema context may not have model by name yet (e.g. still loading). If our id appears in any schema model, we're the schema model.
                     for (const def of Object.values(schemaContext.models)) {
                         if (def?.id === schemaFileId) {
-                            logger$t(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
+                            logger$u(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
                             sendBack({
                                 type: 'loadOrCreateModelSuccess',
                                 model: { id: schemaFileId },
@@ -4079,7 +4253,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
             }
         }
         catch (error) {
-            logger$t(`Error loading model from Schema context: ${error}`);
+            logger$u(`Error loading model from Schema context: ${error}`);
             // Fall through to create new model
         }
         // Step 3: Check for duplicate names in database before creating new model
@@ -4099,7 +4273,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
             // 3. This is an internal schema (internal schemas should preserve original names from schema files), OR
             // 4. This instance was created with modelFileId from schema (_idFromSchema) - schema models keep their name
             const shouldSkipDuplicateCheck = modelRecord !== null || foundBySchemaFileId || isInternal || !!_idFromSchema;
-            logger$t(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
+            logger$u(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
             if (!shouldSkipDuplicateCheck) {
                 try {
                     const lowerModelName = modelName.toLowerCase();
@@ -4111,7 +4285,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                         // Check name-based cache for this schema
                         // Skip the current model (context.id): Model.create() adds the new instance to the cache
                         // before this callback runs, so we must not count it as a duplicate.
-                        logger$t(`Checking Model cache for duplicates in schema "${schemaName}"`);
+                        logger$u(`Checking Model cache for duplicates in schema "${schemaName}"`);
                         const currentModelFileId = schemaFileId ?? null;
                         const cacheByName = Model.instanceCacheByName;
                         for (const [nameKey, cachedModelFileId] of cacheByName.entries()) {
@@ -4122,7 +4296,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                 const lowerCachedName = cachedModelName.toLowerCase();
                                 if (lowerCachedName === lowerModelName) {
                                     existingNumbers.add(0); // Base name exists
-                                    logger$t(`Found duplicate in Model cache: "${cachedModelName}" matches "${modelName}"`);
+                                    logger$u(`Found duplicate in Model cache: "${cachedModelName}" matches "${modelName}"`);
                                 }
                                 else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
                                     // Check if it's the base name followed by a space and a number
@@ -4130,7 +4304,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                     const number = parseInt(suffix, 10);
                                     if (!isNaN(number) && suffix === number.toString()) {
                                         existingNumbers.add(number);
-                                        logger$t(`Found numbered variant in Model cache: "${cachedModelName}" (number: ${number})`);
+                                        logger$u(`Found numbered variant in Model cache: "${cachedModelName}" (number: ${number})`);
                                     }
                                 }
                             }
@@ -4146,7 +4320,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                 const lowerCachedName = cachedModelName.toLowerCase();
                                 if (lowerCachedName === lowerModelName) {
                                     existingNumbers.add(0); // Base name exists
-                                    logger$t(`Found duplicate in Model legacy cache: "${cachedModelName}" matches "${modelName}"`);
+                                    logger$u(`Found duplicate in Model legacy cache: "${cachedModelName}" matches "${modelName}"`);
                                 }
                                 else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
                                     // Check if it's the base name followed by a space and a number
@@ -4154,14 +4328,14 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                     const number = parseInt(suffix, 10);
                                     if (!isNaN(number) && suffix === number.toString()) {
                                         existingNumbers.add(number);
-                                        logger$t(`Found numbered variant in Model legacy cache: "${cachedModelName}" (number: ${number})`);
+                                        logger$u(`Found numbered variant in Model legacy cache: "${cachedModelName}" (number: ${number})`);
                                     }
                                 }
                             }
                         }
                     }
                     catch (error) {
-                        logger$t(`Error checking Model cache for duplicates: ${error}`);
+                        logger$u(`Error checking Model cache for duplicates: ${error}`);
                         // Continue with database check
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
@@ -4171,7 +4345,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                         const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
-                        logger$t(`Checking database for duplicate model names in schema "${schemaName}"`);
+                        logger$u(`Checking database for duplicate model names in schema "${schemaName}"`);
                         const allModelsForSchema = await db
                             .select({
                             name: models$1.name,
@@ -4180,16 +4354,16 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                             .innerJoin(modelSchemas, drizzleOrm.eq(models$1.id, modelSchemas.modelId))
                             .innerJoin(schemasTable, drizzleOrm.eq(modelSchemas.schemaId, schemasTable.id))
                             .where(drizzleOrm.eq(schemasTable.name, schemaName));
-                        logger$t(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
+                        logger$u(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
                         if (allModelsForSchema.length === 0 && modelName.includes('Shared')) {
-                            logger$t(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
+                            logger$u(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
                         }
                         // Check for exact match (case-insensitive) or matches with number suffix
                         for (const dbModel of allModelsForSchema) {
                             const lowerDbName = dbModel.name.toLowerCase();
                             if (lowerDbName === lowerModelName) {
                                 existingNumbers.add(0); // Base name exists
-                                logger$t(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
+                                logger$u(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
                             }
                             else if (lowerDbName.startsWith(lowerModelName + ' ')) {
                                 // Check if it's the base name followed by a space and a number
@@ -4197,48 +4371,48 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                                 const number = parseInt(suffix, 10);
                                 if (!isNaN(number) && suffix === number.toString()) {
                                     existingNumbers.add(number);
-                                    logger$t(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
+                                    logger$u(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
                                 }
                             }
                         }
                     }
                     // If duplicates found, generate unique name
-                    logger$t(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
+                    logger$u(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
                     if (existingNumbers.has(0)) {
                         let nextNumber = 1;
                         while (existingNumbers.has(nextNumber)) {
                             nextNumber++;
                         }
                         finalModelName = `${modelName} ${nextNumber}`;
-                        logger$t(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
+                        logger$u(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
                     }
                     else {
-                        logger$t(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
+                        logger$u(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
                     }
                 }
                 catch (error) {
-                    logger$t(`Error checking for duplicate model names: ${error}`);
+                    logger$u(`Error checking for duplicate model names: ${error}`);
                     // Continue with original name if check fails
                 }
             }
             else {
                 if (foundBySchemaFileId) {
-                    logger$t(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
+                    logger$u(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
                 }
                 else if (modelRecord) {
-                    logger$t(`Using existing model name "${modelName}" from database (modelRecord found)`);
+                    logger$u(`Using existing model name "${modelName}" from database (modelRecord found)`);
                 }
                 else if (isInternal) {
-                    logger$t(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
+                    logger$u(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
                 }
             }
         }
         // Step 4: Create new empty model (not found in database or Schema context)
-        logger$t(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
+        logger$u(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
         // Generate schemaFileId for new model
         if (!schemaFileId) {
             schemaFileId = generateId();
-            logger$t(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
+            logger$u(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
         }
         // Runtime creates use a placeholder cache key in Model.create; move it to the final name. Skip when schema model (_idFromSchema).
         if (!_idFromSchema) {
@@ -4250,7 +4424,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // This avoids the issue where updateContext with modelName triggers validation and state transition
         // We use _pendingModelName (internal field) which won't trigger validation
         if (finalModelName !== modelName) {
-            logger$t(`Model name changed from "${modelName}" to "${finalModelName}", storing in _pendingModelName for loadOrCreateModelSuccess`);
+            logger$u(`Model name changed from "${modelName}" to "${finalModelName}", storing in _pendingModelName for loadOrCreateModelSuccess`);
             // Store the final name in a temporary internal field that will be picked up by loadOrCreateModelSuccess
             sendBack({
                 type: 'updateContext',
@@ -4258,17 +4432,17 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
             });
         }
         else {
-            logger$t(`Model name unchanged: "${modelName}"`);
+            logger$u(`Model name unchanged: "${modelName}"`);
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
         }
         catch (err) {
-            logger$t(`Failed to mark schema as draft after creating model: ${err}`);
+            logger$u(`Failed to mark schema as draft after creating model: ${err}`);
         }
         sendBack({
             type: 'loadOrCreateModelSuccess',
@@ -4278,12 +4452,12 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         });
     };
     _loadOrCreateModel().catch((error) => {
-        logger$t('Error loading or creating model:', error);
+        logger$u('Error loading or creating model:', error);
         sendBack({ type: 'loadOrCreateModelError', error });
     });
 });
 
-const logger$s = debug('seedSdk:model:actors:validateModel');
+const logger$t = debug('seedSdk:model:actors:validateModel');
 // Validation timeout in milliseconds (10 seconds)
 const VALIDATION_TIMEOUT_MS = 10000;
 const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) => {
@@ -4306,10 +4480,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -4350,12 +4524,12 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
                         }
                     }
                     else {
-                        logger$s(`Schema is in ${schemaStatus} state, skipping schema validation`);
+                        logger$t(`Schema is in ${schemaStatus} state, skipping schema validation`);
                         // Continue with structure validation only
                     }
                 }
                 catch (error) {
-                    logger$s('Error validating model against schema:', error);
+                    logger$t('Error validating model against schema:', error);
                     // Continue with structure validation only
                 }
             }
@@ -4370,7 +4544,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
             if (!hasResponded) {
                 hasResponded = true;
                 clearTimeout(timeoutId);
-                logger$s('Error in validateModel:', error);
+                logger$t('Error in validateModel:', error);
                 sendBack({
                     type: 'validationError',
                     errors: [{
@@ -4387,7 +4561,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
         if (!hasResponded) {
             hasResponded = true;
             clearTimeout(timeoutId);
-            logger$s('Error in validateModel:', error);
+            logger$t('Error in validateModel:', error);
             sendBack({
                 type: 'validationError',
                 errors: [{
@@ -4405,7 +4579,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     };
 });
 
-const logger$r = debug('seedSdk:model:actors:createModelProperties');
+const logger$s = debug('seedSdk:model:actors:createModelProperties');
 const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
     const _createProperties = async () => {
         const { context, propertyDefinitions } = input;
@@ -4414,15 +4588,15 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             throw new Error('Model ID, file ID, and name are required to create properties');
         }
         if (!propertyDefinitions || Object.keys(propertyDefinitions).length === 0) {
-            logger$r('No property definitions provided, skipping property creation');
+            logger$s('No property definitions provided, skipping property creation');
             sendBack({ type: 'createModelPropertiesSuccess' });
             return;
         }
-        logger$r(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CDTOx5zi.js'); });
+        logger$s(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
-            logger$r('ModelProperty not available from dynamic import');
+            logger$s('ModelProperty not available from dynamic import');
             sendBack({ type: 'createModelPropertiesError', error: new Error('ModelProperty not available') });
             return;
         }
@@ -4434,7 +4608,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             // IDs should be generated in the import process before creating properties
             const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
             const propertyFileId = propData.id || generateId();
-            logger$r(`Creating property "${propName}" with fileId "${propertyFileId}"`);
+            logger$s(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
             // The property should already be in DB from addModelsToDb
             let refModelId = propData.refModelId;
@@ -4449,7 +4623,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
                         .limit(1);
                     if (propertyRecords.length > 0 && propertyRecords[0].refModelId) {
                         refModelId = propertyRecords[0].refModelId;
-                        logger$r(`Found refModelId ${refModelId} from database for property "${propName}"`);
+                        logger$s(`Found refModelId ${refModelId} from database for property "${propName}"`);
                     }
                     else if (refModelName) {
                         // Fallback: query models table directly by name
@@ -4460,12 +4634,12 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
                             .limit(1);
                         if (refModelRecords.length > 0 && refModelRecords[0].id) {
                             refModelId = refModelRecords[0].id;
-                            logger$r(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
+                            logger$s(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$r(`Error fetching refModelId for property "${propName}":`, error);
+                    logger$s(`Error fetching refModelId for property "${propName}":`, error);
                     // Continue without refModelId - it will be resolved later in _initializeOriginalValues
                 }
             }
@@ -4490,11 +4664,11 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
                 _propertyFileId: propertyFileId, // Store schemaFileId for getById() lookups
             }); // Use 'as any' because _propertyFileId is not in TProperty type
         }
-        logger$r(`Successfully created all properties for model "${modelName}"`);
+        logger$s(`Successfully created all properties for model "${modelName}"`);
         sendBack({ type: 'createModelPropertiesSuccess' });
     };
     _createProperties().catch((error) => {
-        logger$r(`Error creating model properties: ${error}`);
+        logger$s(`Error creating model properties: ${error}`);
         sendBack({
             type: 'createModelPropertiesError',
             error: error instanceof Error ? error : new Error(String(error))
@@ -4505,7 +4679,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
     };
 });
 
-const logger$q = debug('seedSdk:write:validateEntity');
+const logger$r = debug('seedSdk:write:validateEntity');
 // XState v5 type inference bug: fromPromise types are inverted
 // We use type assertion to work around this
 const validateEntity = xstate.fromPromise(async ({ input }) => {
@@ -4515,20 +4689,20 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     const _validate = async () => {
         try {
             const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
-            logger$q(msg);
-            logger$q(`[validateEntity] Entity data:`, entityInput.entityData);
+            logger$r(msg);
+            logger$r(`[validateEntity] Entity data:`, entityInput.entityData);
             let result = { isValid: true, errors: [] };
             if (entityInput.entityType === 'model') {
                 const structureMsg = `[validateEntity] Validating model structure`;
-                logger$q(structureMsg);
+                logger$r(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
                 const structureResult = validationService.validateModelStructure(entityInput.entityData);
                 const structureResultMsg = `[validateEntity] Structure validation result: isValid=${structureResult.isValid}, errors=${structureResult.errors?.length || 0}`;
-                logger$q(structureResultMsg);
+                logger$r(structureResultMsg);
                 if (!structureResult.isValid) {
                     result = {
                         isValid: false,
@@ -4539,20 +4713,20 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name provided, validate against schema
                     if (entityInput.entityData.schemaName) {
                         try {
-                            logger$q(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+                            logger$r(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
                             });
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
-                            logger$q(`[validateEntity] Schema status: ${schemaStatus}`);
+                            logger$r(`[validateEntity] Schema status: ${schemaStatus}`);
                             if (schemaStatus === 'idle') {
                                 const schemaContext = schemaSnapshot.context;
-                                logger$q(`[validateEntity] Running validateModelAgainstSchema`);
+                                logger$r(`[validateEntity] Running validateModelAgainstSchema`);
                                 const schemaResult = validationService.validateModelAgainstSchema(schemaContext, entityInput.entityData.modelName, entityInput.entityData);
-                                logger$q(`[validateEntity] Schema validation result:`, schemaResult);
+                                logger$r(`[validateEntity] Schema validation result:`, schemaResult);
                                 if (!schemaResult.isValid) {
                                     result = {
                                         isValid: false,
@@ -4561,22 +4735,22 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                                 }
                             }
                             else {
-                                logger$q(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
+                                logger$r(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
                             }
                         }
                         catch (error) {
-                            logger$q('Error validating model against schema:', error);
+                            logger$r('Error validating model against schema:', error);
                             // Continue with structure validation only
                         }
                     }
                     else {
-                        logger$q(`[validateEntity] No schemaName provided, skipping schema validation`);
+                        logger$r(`[validateEntity] No schemaName provided, skipping schema validation`);
                     }
                 }
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -4591,7 +4765,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -4612,7 +4786,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                             }
                         }
                         catch (error) {
-                            logger$q('Error validating property against schema:', error);
+                            logger$r('Error validating property against schema:', error);
                             // Continue with structure validation only
                         }
                     }
@@ -4620,7 +4794,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -4633,14 +4807,14 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             // Return the result - fromPromise will automatically put this in event.output
             const completeMsg = `[validateEntity] Validation complete: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-            logger$q(completeMsg);
-            logger$q(`[validateEntity] Validation complete:`, result);
+            logger$r(completeMsg);
+            logger$r(`[validateEntity] Validation complete:`, result);
             return result;
         }
         catch (error) {
             const errorMsg = `[validateEntity] Error in validateEntity: ${error instanceof Error ? error.message : String(error)}`;
-            logger$q(errorMsg);
-            logger$q('Error in validateEntity:', error);
+            logger$r(errorMsg);
+            logger$r('Error in validateEntity:', error);
             // Throw error - fromPromise will automatically create error.platform event
             throw error;
         }
@@ -4649,7 +4823,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     // @ts-ignore - XState v5 type inference bug: fromPromise incorrectly expects output type to match input type
 });
 
-const logger$p = debug('seedSdk:write:writeToDatabase');
+const logger$q = debug('seedSdk:write:writeToDatabase');
 const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
     const _write = async () => {
         try {
@@ -4660,8 +4834,8 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
             let output = input.entityData;
             if (input.entityType === 'model') {
                 const writeMsg = `Writing model to database: ${input.entityData.modelName} (schemaId: ${input.entityData.schemaId})`;
-                logger$p(writeMsg);
-                logger$p(`Writing model to database:`, {
+                logger$q(writeMsg);
+                logger$q(`Writing model to database:`, {
                     modelFileId: input.entityId,
                     modelName: input.entityData.modelName,
                     schemaId: input.entityData.schemaId,
@@ -4686,14 +4860,14 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                     output = input.entityData;
                 }
                 const successMsg = `Successfully wrote model "${input.entityData.modelName}" to database`;
-                logger$p(successMsg);
+                logger$q(successMsg);
             }
             else if (input.entityType === 'modelProperty') {
                 // Use current ModelProperty context when available so a user rename before the
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-CDTOx5zi.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4735,7 +4909,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
             });
         }
         catch (error) {
-            logger$p('Error in writeToDatabase:', error);
+            logger$q('Error in writeToDatabase:', error);
             sendBack({
                 type: 'writeError',
                 error: error instanceof Error ? error : new Error(String(error)),
@@ -4743,7 +4917,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
         }
     };
     _write().catch((error) => {
-        logger$p('Error in writeToDatabase promise:', error);
+        logger$q('Error in writeToDatabase promise:', error);
         sendBack({
             type: 'writeError',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -4754,7 +4928,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
     };
 });
 
-const logger$o = debug('seedSdk:write:writeProcessMachine');
+const logger$p = debug('seedSdk:write:writeProcessMachine');
 const writeProcessMachine = xstate.setup({
     types: {
         context: {},
@@ -4792,8 +4966,8 @@ const writeProcessMachine = xstate.setup({
                             writeStatus: 'validating',
                         }),
                         ({ event, context }) => {
-                            logger$o(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
-                            logger$o(`[startWrite] Data:`, event.data);
+                            logger$p(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
+                            logger$p(`[startWrite] Data:`, event.data);
                         },
                     ],
                 },
@@ -4802,14 +4976,14 @@ const writeProcessMachine = xstate.setup({
         validating: {
             entry: ({ context }) => {
                 const msg = `[validating] Entering validating state for ${context.entityType} "${context.entityId}"`;
-                logger$o(msg);
-                logger$o(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
+                logger$p(msg);
+                logger$p(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
             },
             invoke: {
                 src: 'validateEntity',
                 input: ({ context }) => {
                     const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$o(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
+                    logger$p(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
                     return {
                         entityType: context.entityType,
                         entityData,
@@ -4837,8 +5011,8 @@ const writeProcessMachine = xstate.setup({
                                 return false;
                             }
                             const resultMsg = `[validating] Validation result: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-                            logger$o(resultMsg);
-                            logger$o(`[validating] Validation result:`, result);
+                            logger$p(resultMsg);
+                            logger$p(`[validating] Validation result:`, result);
                             return result.isValid;
                         },
                         actions: [
@@ -4848,7 +5022,7 @@ const writeProcessMachine = xstate.setup({
                             }),
                             ({ context }) => {
                                 const msg = `[validating] Validation passed, transitioning to writing for ${context.entityType} "${context.entityId}"`;
-                                logger$o(msg);
+                                logger$p(msg);
                             },
                         ],
                     },
@@ -4868,7 +5042,7 @@ const writeProcessMachine = xstate.setup({
                             }),
                             ({ context, event }) => {
                                 const result = event.output;
-                                logger$o(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
+                                logger$p(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
                             },
                         ],
                     },
@@ -4882,7 +5056,7 @@ const writeProcessMachine = xstate.setup({
                         }),
                         ({ context, event }) => {
                             const errorMsg = `[validating] Validation error for ${context.entityType} "${context.entityId}": ${event.error}`;
-                            logger$o(errorMsg);
+                            logger$p(errorMsg);
                             console.error(errorMsg, event.error); // Always log to console
                         },
                     ],
@@ -4897,8 +5071,8 @@ const writeProcessMachine = xstate.setup({
                 src: 'writeToDatabase',
                 input: ({ context }) => {
                     const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$o(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
-                    logger$o(`[writing] Entity data:`, entityData);
+                    logger$p(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
+                    logger$p(`[writing] Entity data:`, entityData);
                     return {
                         entityType: context.entityType,
                         entityId: context.entityId,
@@ -4919,7 +5093,7 @@ const writeProcessMachine = xstate.setup({
                             },
                         }),
                         ({ context }) => {
-                            logger$o(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
+                            logger$p(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
                         },
                     ],
                 },
@@ -4932,7 +5106,7 @@ const writeProcessMachine = xstate.setup({
                             retryCount: ({ context }) => context.retryCount + 1,
                         }),
                         ({ context, event }) => {
-                            logger$o(`[writing] Write error for ${context.entityType} "${context.entityId}":`, event.error);
+                            logger$p(`[writing] Write error for ${context.entityType} "${context.entityId}":`, event.error);
                         },
                     ],
                 },
@@ -4973,7 +5147,7 @@ const writeProcessMachine = xstate.setup({
     },
 });
 
-const logger$n = debug('seedSdk:model:modelMachine');
+const logger$o = debug('seedSdk:model:modelMachine');
 const modelMachine = xstate.setup({
     types: {
         context: {},
@@ -5073,23 +5247,23 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-CDTOx5zi.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
                                                 if (property) {
-                                                    logger$n(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
+                                                    logger$o(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
                                                 }
                                             }
                                             catch (error) {
-                                                logger$n(`[modelMachine] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                                                logger$o(`[modelMachine] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                                             }
                                         });
                                         Promise.all(createPromises).catch((error) => {
-                                            logger$n(`[modelMachine] Error creating property instances: ${error}`);
+                                            logger$o(`[modelMachine] Error creating property instances: ${error}`);
                                         });
                                     }).catch((error) => {
-                                        logger$n(`[modelMachine] Error importing ModelProperty: ${error}`);
+                                        logger$o(`[modelMachine] Error importing ModelProperty: ${error}`);
                                     });
                                 }
                             }, 0);
@@ -5174,11 +5348,11 @@ const modelMachine = xstate.setup({
                     target: 'idle',
                     actions: xstate.assign(({ context, event }) => {
                         const hasPendingProps = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                        logger$n(`[loadOrCreateModelSuccess] Preserving _pendingPropertyDefinitions: ${hasPendingProps} (${Object.keys(context._pendingPropertyDefinitions || {}).length} properties)`);
+                        logger$o(`[loadOrCreateModelSuccess] Preserving _pendingPropertyDefinitions: ${hasPendingProps} (${Object.keys(context._pendingPropertyDefinitions || {}).length} properties)`);
                         // Check if there's a pending model name update (set before this event to avoid validation trigger)
                         const finalModelName = context._pendingModelName || context.modelName;
                         if (context._pendingModelName) {
-                            logger$n(`[loadOrCreateModelSuccess] Applying pending model name: "${context.modelName}" -> "${finalModelName}"`);
+                            logger$o(`[loadOrCreateModelSuccess] Applying pending model name: "${context.modelName}" -> "${finalModelName}"`);
                         }
                         return {
                             ...context,
@@ -5219,7 +5393,7 @@ const modelMachine = xstate.setup({
             entry: xstate.assign({
                 writeProcess: ({ context, spawn }) => {
                     if (!context.writeProcess && context.id) {
-                        logger$n(`[idle entry] Spawning writeProcess for model "${context.modelName}" (${context.id})`);
+                        logger$o(`[idle entry] Spawning writeProcess for model "${context.modelName}" (${context.id})`);
                         return spawn(writeProcessMachine, {
                             input: {
                                 entityType: 'model',
@@ -5240,7 +5414,7 @@ const modelMachine = xstate.setup({
                     actions: ({ self }) => {
                         // This event will be handled by the Model instance's subscription
                         // The Model will call _refreshPropertiesFromDb when it receives this event
-                        logger$n(`[idle] refreshProperties event received, will be handled by Model instance`);
+                        logger$o(`[idle] refreshProperties event received, will be handled by Model instance`);
                     },
                 },
                 validateModel: {
@@ -5252,14 +5426,14 @@ const modelMachine = xstate.setup({
                 requestWrite: {
                     actions: ({ context, event }) => {
                         if (context.writeProcess) {
-                            logger$n(`[requestWrite] Sending startWrite to writeProcess with data:`, event.data);
+                            logger$o(`[requestWrite] Sending startWrite to writeProcess with data:`, event.data);
                             context.writeProcess.send({
                                 type: 'startWrite',
                                 data: event.data,
                             });
                         }
                         else {
-                            logger$n(`[requestWrite] ERROR: writeProcess not available for model "${context.modelName}" (${context.id})`);
+                            logger$o(`[requestWrite] ERROR: writeProcess not available for model "${context.modelName}" (${context.id})`);
                         }
                     },
                 },
@@ -5268,18 +5442,18 @@ const modelMachine = xstate.setup({
                         guard: ({ context }) => {
                             // If we have pending property definitions, transition to creatingProperties
                             const hasPending = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                            logger$n(`[writeSuccess guard] hasPending: ${hasPending}, _pendingPropertyDefinitions keys: ${context._pendingPropertyDefinitions ? Object.keys(context._pendingPropertyDefinitions).length : 0}`);
+                            logger$o(`[writeSuccess guard] hasPending: ${hasPending}, _pendingPropertyDefinitions keys: ${context._pendingPropertyDefinitions ? Object.keys(context._pendingPropertyDefinitions).length : 0}`);
                             return hasPending;
                         },
                         target: 'creatingProperties',
                         actions: xstate.assign(({ context, event }) => {
-                            logger$n(`[writeSuccess] Transitioning to creatingProperties for model "${context.modelName}"`);
+                            logger$o(`[writeSuccess] Transitioning to creatingProperties for model "${context.modelName}"`);
                             // Update _dbId from write output if available (writeToDatabase returns _dbId, not id)
                             const newContext = { ...context };
                             const dbId = event.output?._dbId ?? event.output?.id;
                             if (dbId != null) {
                                 newContext._dbId = dbId;
-                                logger$n(`[writeSuccess] Updated _dbId to ${dbId}`);
+                                logger$o(`[writeSuccess] Updated _dbId to ${dbId}`);
                             }
                             return newContext;
                         }),
@@ -5324,12 +5498,12 @@ const modelMachine = xstate.setup({
         },
         creatingProperties: {
             entry: ({ context }) => {
-                logger$n(`[creatingProperties entry] Starting property creation for model "${context.modelName}" with ${Object.keys(context._pendingPropertyDefinitions || {}).length} properties`);
+                logger$o(`[creatingProperties entry] Starting property creation for model "${context.modelName}" with ${Object.keys(context._pendingPropertyDefinitions || {}).length} properties`);
             },
             invoke: {
                 src: 'createModelProperties',
                 input: ({ context }) => {
-                    logger$n(`[creatingProperties invoke] Invoking createModelProperties with ${Object.keys(context._pendingPropertyDefinitions || {}).length} property definitions`);
+                    logger$o(`[creatingProperties invoke] Invoking createModelProperties with ${Object.keys(context._pendingPropertyDefinitions || {}).length} property definitions`);
                     return {
                         context,
                         propertyDefinitions: context._pendingPropertyDefinitions || {},
@@ -5359,7 +5533,7 @@ const modelMachine = xstate.setup({
                 createModelPropertiesError: {
                     target: 'error',
                     actions: ({ event }) => {
-                        logger$n('Error creating model properties:', event.error);
+                        logger$o('Error creating model properties:', event.error);
                     },
                 },
             },
@@ -5548,6 +5722,10 @@ var PublishMachineStates;
     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';
@@ -5845,34 +6023,6 @@ const hydrateNewItem = xstate.fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-/**
- * Convert Model.properties array to object format (for backward compatibility)
- * This replaces the old model.schema getter
- */
-function modelPropertiesToObject(properties) {
-    const schemaObj = {};
-    for (const property of properties) {
-        const propContext = property._getSnapshotContext();
-        if (propContext.name) {
-            schemaObj[propContext.name] = {
-                dataType: propContext.dataType,
-                ref: propContext.refModelName || propContext.ref,
-                refValueType: propContext.refValueType,
-                storageType: propContext.storageType,
-                localStorageDir: propContext.localStorageDir,
-                filenameSuffix: propContext.filenameSuffix,
-                required: propContext.required,
-            };
-        }
-    }
-    return schemaObj;
-}
-
-var model = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    modelPropertiesToObject: modelPropertiesToObject
-});
-
 const fetchDataFromEas = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { ModelClass, modelTableName, versionUid, modelName } = context;
     const _initializeAndFetch = async () => {
@@ -6071,7 +6221,7 @@ function compareMetadataRowsLatestFirst(a, b) {
     return kb.localId.localeCompare(ka.localId);
 }
 
-const logger$m = debug('seedSdk:item:actors:loadOrCreateItem');
+const logger$n = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
  */
@@ -6161,16 +6311,16 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
                         propertySchemas = schemaContext.models[modelName].properties;
-                        logger$m(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
+                        logger$n(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
                     }
                 }
                 catch (err) {
-                    logger$m(`Fallback Schema context failed for ${modelName}: ${err}`);
+                    logger$n(`Fallback Schema context failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
@@ -6181,13 +6331,13 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const models = schemaFile.models;
                         if (models?.[modelName]?.properties) {
                             propertySchemas = models[modelName].properties;
-                            logger$m(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
+                            logger$n(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$m(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
+                    logger$n(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
@@ -6200,17 +6350,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const schemaFile = JSON.parse(content);
                         if (schemaFile.models?.[modelName]?.properties) {
                             propertySchemas = schemaFile.models[modelName].properties;
-                            logger$m(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
+                            logger$n(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$m(`Fallback schema file scan failed for ${modelName}: ${err}`);
+                    logger$n(`Fallback schema file scan failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -6222,10 +6372,13 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 };
                 if (KNOWN_MODEL_FALLBACKS[modelName]) {
                     propertySchemas = KNOWN_MODEL_FALLBACKS[modelName];
-                    logger$m(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
+                    logger$n(`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 Promise.resolve().then(function () { return require('./property-DlKiAWt4.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.
@@ -6237,7 +6390,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             try {
                 let propertyName = metaRow.propertyName;
                 if (!propertyName) {
-                    logger$m(`Metadata row missing propertyName, skipping`);
+                    logger$n(`Metadata row missing propertyName, skipping`);
                     continue;
                 }
                 const listSchemaKey = resolveStorageNameToSchemaName(propertySchemas, propertyName);
@@ -6257,7 +6410,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6285,14 +6438,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$m(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
+                    logger$n(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$m(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
+                    logger$n(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
-                logger$m(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
+                logger$n(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
             }
         }
         // Create placeholder ItemProperty instances for model schema properties without metadata
@@ -6314,17 +6467,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$m(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
+                    logger$n(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
                 }
             }
             catch (error) {
-                logger$m(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
+                logger$n(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
             }
         }
-        logger$m(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
+        logger$n(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
     }
     catch (error) {
-        logger$m(`Error in createItemPropertyInstances: ${error}`);
+        logger$n(`Error in createItemPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
     return propertyInstances;
@@ -6332,7 +6485,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
 const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        logger$m(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$n(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -6362,7 +6515,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .limit(1);
         if (seedRecords.length === 0) {
             // Seed not found - this is a new item, will be created elsewhere
-            logger$m(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+            logger$n(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6403,7 +6556,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .where(drizzleOrm.eq(seeds.localId, resolvedSeedLocalId))
             .limit(1);
         if (versionRecords.length === 0) {
-            logger$m(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$n(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6427,7 +6580,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
         const latestVersionLocalId = versionRecord.latestVersionLocalId;
         const latestVersionUid = versionRecord.latestVersionUid || undefined;
         if (!latestVersionLocalId) {
-            logger$m(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$n(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6458,7 +6611,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .select()
             .from(metadataLatest)
             .where(drizzleOrm.eq(metadataLatest.rowNum, 1));
-        logger$m(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
+        logger$n(`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);
@@ -6490,7 +6643,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
         });
     };
     _loadOrCreateItem().catch((error) => {
-        logger$m(`Error in loadOrCreateItem: ${error}`);
+        logger$n(`Error in loadOrCreateItem: ${error}`);
         sendBack({
             type: 'loadOrCreateItemError',
             error: error instanceof Error ? error.message : String(error),
@@ -6498,7 +6651,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
     });
 });
 
-const logger$l = debug('seedSdk:Item:runPublish');
+const logger$m = debug('seedSdk:Item:runPublish');
 const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { seedLocalId } = context;
     const _runPublish = async () => {
@@ -6514,21 +6667,21 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DNULcrN5.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DMhCCKYF.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-Jmgi1RUj.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-D5DhLGvN.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
             const executor = getUploadExecutor();
             if (executor && uploads.length > 0) ;
             await getPublishPayload(item, uploadedTransactions);
-            logger$l('runPublish: payload prepared (upload/EAS submit stubbed)');
+            logger$m('runPublish: payload prepared (upload/EAS submit stubbed)');
             sendBack({ type: 'publishSuccess' });
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            logger$l('runPublish error:', error);
+            logger$m('runPublish error:', error);
             sendBack({ type: 'publishError', error });
         }
     };
@@ -6887,7 +7040,7 @@ async function getLatestPublishedVersionRow(seedLocalId) {
     return null;
 }
 
-const logger$k = debug('seedSdk:db:read:getItemData');
+const logger$l = debug('seedSdk:db:read:getItemData');
 /**
  * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
  *
@@ -6903,7 +7056,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$k('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$l('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId || undefined;
@@ -6930,9 +7083,9 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .from(seeds)
         .where(drizzleOrm.and(...whereClauses))
         .limit(1);
-    logger$k('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
+    logger$l('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
     if (!seedRows || seedRows.length === 0) {
-        logger$k('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
+        logger$l('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
         return;
     }
     const seedRow = seedRows[0];
@@ -6954,7 +7107,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
             }
         }
         catch (error) {
-            logger$k('[getItemData] Error deriving schemaName:', error);
+            logger$l('[getItemData] Error deriving schemaName:', error);
         }
     }
     // Now get version data if it exists - query versions table directly
@@ -7338,12 +7491,12 @@ const resolveRemoteStorage = xstate.fromCallback(({ sendBack, input: { context }
     });
 });
 
-const logger$j = debug('seedSdk:ItemProperty:service:actors:waitForDb');
+const logger$k = debug('seedSdk:ItemProperty:service:actors:waitForDb');
 const waitForDb = xstate.fromCallback(({ sendBack }) => {
     // Check immediately first
     const appDb = BaseDb.getAppDb();
     if (appDb) {
-        logger$j('Database is ready (immediate check)');
+        logger$k('Database is ready (immediate check)');
         sendBack({ type: 'waitForDbSuccess' });
         return;
     }
@@ -7355,24 +7508,24 @@ const waitForDb = xstate.fromCallback(({ sendBack }) => {
             const appDb = BaseDb.getAppDb();
             if (appDb) {
                 clearInterval(interval);
-                logger$j('Database is ready (after polling)');
+                logger$k('Database is ready (after polling)');
                 resolve();
             }
             else if (Date.now() - startTime > timeout) {
                 clearInterval(interval);
                 const error = new Error('Database not available after timeout');
-                logger$j(`Database wait timeout: ${error.message}`);
+                logger$k(`Database wait timeout: ${error.message}`);
                 reject(error);
             }
         }, 100);
     });
     _waitForDb
         .then(() => {
-        logger$j('Sending waitForDbSuccess event');
+        logger$k('Sending waitForDbSuccess event');
         sendBack({ type: 'waitForDbSuccess' });
     })
         .catch((error) => {
-        logger$j(`Error waiting for database: ${error}`);
+        logger$k(`Error waiting for database: ${error}`);
         sendBack({ type: 'waitForDbError', error: error.message });
     });
 });
@@ -7466,7 +7619,7 @@ const getRelationValueData = async (propertyValue) => {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> resolveRelatedValue -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$i = debug('seedSdk:property:actors:resolveRelatedValue');
+const logger$j = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -7474,14 +7627,14 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$i(`${propertyName} value is an array of seedUids`);
+            logger$j(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (typeof propertyValue === 'object') {
@@ -7493,7 +7646,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
             parsedValue = JSON.parse(relationKey);
         }
         catch (error) {
-            logger$i(`${propertyName} value is not a JSON string.`);
+            logger$j(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(relationKey)) {
             const contentUrl = seedUidToContentUrl.get(relationKey);
@@ -7508,7 +7661,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
             return true;
         }
         if (Array.isArray(parsedValue)) {
-            logger$i(`${propertyName} value is a stringified array of seedUids`);
+            logger$j(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(relationKey);
@@ -7548,7 +7701,7 @@ const resolveRelatedValue = xstate.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 &&
@@ -7851,48 +8004,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 = arweave.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 = arweave.getResolvedSeedGatewayEndpoints();
-    const hosts = resolved
-        ? arweave.getReadGatewayHostsForConfig(resolved, arweave.getDefaultArweaveReadGatewayHostsOrdered())
-        : arweave.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 arweave.fetchArweaveRawTextAcrossGateways(id);
 }
 /**
  * Resolve the Html storage seed's `local_id` used for the `{localId}.html` file name.
@@ -7990,7 +8110,7 @@ async function readHtmlBodyForStorageSeedPropertyValue(propertyValue) {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$h = debug('seedSdk:property:actors:hydrateFromDb');
+const logger$i = debug('seedSdk:property:actors:hydrateFromDb');
 const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
     if (!propertyNameRaw) {
@@ -8001,7 +8121,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -8107,7 +8227,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                     }
                 }
                 catch (e) {
-                    logger$h('[hydrateFromDb] Image file resolution error', e);
+                    logger$i('[hydrateFromDb] Image file resolution error', e);
                 }
             }
         }
@@ -8138,7 +8258,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$h('[hydrateFromDb] File resolution error', e);
+                logger$i('[hydrateFromDb] File resolution error', e);
             }
         }
         if (propertyRecordSchema &&
@@ -8241,11 +8361,11 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-const logger$g = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$h = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$g(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$h(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -8291,15 +8411,15 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         const schemas = modelPropertiesToObject(model$1.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$g(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$h(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$g(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$h(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$g(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$h(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -8365,7 +8485,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-DmvgA8FD.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-DlKiAWt4.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8403,7 +8523,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (error) {
-                logger$g(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$h(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
@@ -8421,12 +8541,12 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                     const schemas = modelPropertiesToObject(model$1.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$g(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$h(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$g(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$h(`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)
@@ -8467,7 +8587,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$g(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$h(`Failed to read Html file for ${propertyName}: ${e}`);
             }
         }
         // Covers missing ref row, wrong ref, or DB dataType casing "html" (handled by isHtml above).
@@ -8525,7 +8645,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         });
                     }
                     catch (e) {
-                        logger$g(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
+                        logger$h(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
                     }
                 }
             }
@@ -8547,7 +8667,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$g(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$h(`Failed to resolve Image file for ${propertyName}: ${e}`);
             }
         }
         const isFile = refSeedType === 'file' ||
@@ -8565,7 +8685,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$g(`Failed to resolve File for ${propertyName}: ${e}`);
+                logger$h(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -8597,7 +8717,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$g(`Error in loadOrCreateProperty: ${error}`);
+        logger$h(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -8627,10 +8747,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$f = debug('seedSdk:write:updateItemPropertyValue');
+const logger$g = 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$f(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$g(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     let safeNewValue = newValue;
@@ -8703,7 +8823,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$f(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$g(`[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
@@ -8831,9 +8951,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -9008,6 +9128,12 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
     if (!metadataValues.modelType && metadataValues.modelName) {
         metadataValues.modelType = casing.toSnakeCase(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 &&
@@ -9022,7 +9148,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);
         }
     }
@@ -9031,7 +9161,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-Z7OhtGn5.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -9082,29 +9212,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}`);
     }
@@ -9624,7 +9769,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9637,7 +9782,7 @@ const saveRelation = xstate.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,
@@ -9827,7 +9972,19 @@ const saveItemStorage = xstate.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 = xstate.setup({
     types: {
         context: {},
@@ -9868,6 +10025,7 @@ const propertyMachine = xstate.setup({
             actions: xstate.assign({
                 isSaving: true,
                 _saveError: undefined,
+                _saveValidationErrors: undefined,
             }),
             target: '.saving',
         },
@@ -9881,7 +10039,9 @@ const propertyMachine = xstate.setup({
                     }
                     newContext[key] = event[key];
                 }
-                return newContext;
+                return 'propertyRecordSchema' in event
+                    ? withListRelationStorageName(newContext)
+                    : newContext;
             }),
         },
         destroyStarted: {
@@ -9940,7 +10100,7 @@ const propertyMachine = xstate.setup({
                     target: 'idle',
                     actions: xstate.assign(({ context, event }) => {
                         const property = event.property;
-                        return {
+                        return withListRelationStorageName({
                             ...context,
                             propertyName: property.propertyName || context.propertyName,
                             propertyValue: property.propertyValue !== undefined ? property.propertyValue : context.propertyValue,
@@ -9958,7 +10118,7 @@ const propertyMachine = xstate.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: {
@@ -10445,7 +10605,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;
         }
@@ -10465,7 +10626,7 @@ const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, mod
 };
 /** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
 const modelTypeToModelName = (modelType) => modelType ? lodashEs.upperFirst(lodashEs.camelCase(modelType)) : '';
-const logger$e = debug('seedSdk:property:class');
+const logger$f = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES$2 = [
@@ -10486,18 +10647,29 @@ const TRACKED_PROPERTIES$2 = [
 // 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 = {
@@ -10511,7 +10683,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,
@@ -10523,16 +10695,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, exports.ModelPropertyDataTypes.Relation)) {
                 this._isRelation = true;
             }
-            if (propertyRecordSchema.dataType === 'List') {
+            if (isDataType(propertyRecordSchema.dataType, exports.ModelPropertyDataTypes.List)) {
                 this._isList = true;
                 const listRef = propertyRecordSchema.ref ||
                     propertyRecordSchema.refModelName;
@@ -10547,7 +10716,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$e('List property value is not JSON', e);
+                        logger$f('List property value is not JSON', e);
                     }
                 }
             }
@@ -10570,7 +10739,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-tpO1Nj4v.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DPp9rdRL.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -10585,9 +10754,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' &&
@@ -10664,7 +10833,7 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$e(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$f(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = isHtml ? undefined : 'No file found';
                 }
             }
@@ -10992,8 +11161,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, exports.ModelPropertyDataTypes.Relation)) {
                             ;
                             this._isRelation = true;
                         }
@@ -11001,7 +11170,7 @@ class ItemProperty {
                             ;
                             this._isRelation = false;
                         }
-                        if (propertyRecordSchema.dataType === 'List') {
+                        if (isDataType(propertyRecordSchema.dataType, exports.ModelPropertyDataTypes.List)) {
                             ;
                             this._isList = true;
                             this._isRelation = !!(propertyRecordSchema.ref);
@@ -11073,11 +11242,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, exports.ModelPropertyDataTypes.Relation);
+                instance._isList = isDataType(incomingSchema.dataType, exports.ModelPropertyDataTypes.List);
                 instance._service.send({
                     type: 'updateContext',
                     propertyRecordSchema: incomingSchema,
@@ -11375,7 +11544,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() {
@@ -11412,7 +11590,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 ?? [];
     }
@@ -11450,11 +11628,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 {
@@ -11484,9 +11668,23 @@ class ItemProperty {
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
         });
-        await xstate.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 xstate.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 });
@@ -11511,6 +11709,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],
@@ -11604,7 +11810,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
@@ -11790,6 +11997,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, exports.ModelPropertyDataTypes.File) ||
+        isDataType(dataType, exports.ModelPropertyDataTypes.Image) ||
+        isDataType(dataType, exports.ModelPropertyDataTypes.Html);
+    return isStorageType && !isStorageSeedRef(value);
+}
 const TRACKED_PROPERTIES$1 = [
     'seedLocalId',
     'seedUid',
@@ -11881,12 +12097,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DNULcrN5.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DMhCCKYF.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-Jmgi1RUj.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-D5DhLGvN.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -12347,6 +12563,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
@@ -12375,13 +12592,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(drizzleOrm.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)) {
@@ -12390,6 +12614,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;
@@ -12398,6 +12626,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;
@@ -12497,7 +12730,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);
@@ -12511,8 +12745,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 xstate.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
@@ -13543,7 +13815,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-3hOoPdu1.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-C6n34o_Q.js'); });
     try {
         await runSyncFromEas(toRunSyncArg(input.options));
         await finalizeEasSyncProcessRow(rowId, {
@@ -13760,10 +14032,10 @@ var easSyncManager = /*#__PURE__*/Object.freeze({
     startEasSyncActor: startEasSyncActor
 });
 
-const logger$d = debug('seedSdk:services:events');
+const logger$e = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$d(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$e(`[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))
 };
@@ -13847,9 +14119,32 @@ class BasePathResolver {
 }
 BasePathResolver._impl = null;
 
-const logger$c = 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$d = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$c('initialize from ClientManager');
+    logger$d('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -13873,8 +14168,10 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
         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');
         }
@@ -13896,13 +14193,20 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
         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: eas$1 } = config;
+        if (eas$1) {
+            eas.configureEasReadChain('sdk', { chainId: eas$1.chainId, indexerUrl: eas$1.indexerUrl });
+        }
         const gatewayConfig = arweave.seedGatewayConfigFromSeedConfig({
             ...config,
             arweaveDomain,
             uploadApiBaseUrl,
             gateway,
         });
+        // Only when configured, so a host app's own setPreferredArweaveReadBaseUrls() call survives init.
+        if (gatewayConfig.preferredReadBaseUrls) {
+            arweave.setPreferredArweaveReadBaseUrls(gatewayConfig.preferredReadBaseUrls);
+        }
         const resolvedGateway = await arweave.resolveSeedGatewayEndpoints(gatewayConfig);
         arweave.setResolvedSeedGatewayEndpoints(resolvedGateway);
         arweave.BaseArweaveClient.setHost(`${resolvedGateway.arweaveProtocol}://${resolvedGateway.arweaveHost}`);
@@ -14008,7 +14312,7 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
     };
 });
 
-const logger$b = debug('seedSdk:client:writeToDb');
+const logger$c = debug('seedSdk:client:writeToDb');
 const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
@@ -14016,7 +14320,7 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$b('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$c('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -14032,13 +14336,13 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
                     value: JSON.stringify(value),
                 },
             });
-            logger$b('result', result);
+            logger$c('result', result);
         }
         catch (error) {
-            logger$b('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$c('[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$b('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$c('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -14053,10 +14357,10 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
         });
     })
         .catch((error) => {
-        logger$b('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$c('[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$b('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$c('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -14126,7 +14430,7 @@ const fileSystemInit = xstate.fromCallback(({ sendBack, input: { context }, }) =
     };
 });
 
-const logger$a = debug('seedSdk:client:actors:dbInit');
+const logger$b = debug('seedSdk:client:actors:dbInit');
 const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _dbInit = async () => {
         const { filesDir } = context;
@@ -14140,14 +14444,14 @@ const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
         if (!appDb) {
             throw new Error('Database not available after preparation');
         }
-        logger$a('[client/actors] [dbInit] Database prepared and ready');
+        logger$b('[client/actors] [dbInit] Database prepared and ready');
     };
     _dbInit()
         .then(() => {
         sendBack({ type: ClientManagerEvents.DB_READY });
     })
         .catch((error) => {
-        logger$a('Error in dbInit:', error);
+        logger$b('Error in dbInit:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
@@ -14155,7 +14459,7 @@ const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$9 = debug('seedSdk:client:actors:addModelsToStore');
+const logger$a = debug('seedSdk:client:actors:addModelsToStore');
 const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _addModelsToStore = async () => {
         let { models } = context;
@@ -14169,7 +14473,7 @@ const addModelsToStore = xstate.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$9('model available:', key);
+            logger$a('model available:', key);
         }
     };
     _addModelsToStore()
@@ -14177,7 +14481,7 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
     })
         .catch((error) => {
-        logger$9('[client/actors] [addModelsToStore] Error:', error);
+        logger$a('[client/actors] [addModelsToStore] Error:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -14185,7 +14489,7 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
     });
 });
 
-const logger$8 = debug('seedSdk:client:actors:addModelsToDb');
+const logger$9 = debug('seedSdk:client:actors:addModelsToDb');
 const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { models } = context;
     const _addModelsToDb = async () => {
@@ -14223,14 +14527,14 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                 existingByName.set(m.name, m);
             }
             for (const name of modelsToInsert) {
-                logger$8('[client/actors] [addModelsToDb] inserted model:', name);
+                logger$9('[client/actors] [addModelsToDb] inserted model:', name);
             }
         }
         let hasModelsInDb = true;
         for (const modelName of modelNames) {
             const foundModel = existingByName.get(modelName);
             if (!foundModel) {
-                logger$8('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                logger$9('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
                 hasModelsInDb = false;
                 continue;
             }
@@ -14241,7 +14545,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
         }
         // If we have no models to process, still send success (empty models is valid)
         if (schemaDefsByModelName.size === 0) {
-            logger$8('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$9('[client/actors] [addModelsToDb] No models to process, but continuing');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
             return;
         }
@@ -14284,15 +14588,15 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$8('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                    logger$9('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
                 }
             }
             catch (error) {
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$8('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
+                    logger$9('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
                 }
                 else {
-                    logger$8('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                    logger$9('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 }
             }
         };
@@ -14304,10 +14608,10 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
     })
         .catch((error) => {
-        logger$8('[client/actors] [addModelsToDb] Error:', error);
+        logger$9('[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$8('[client/actors] [addModelsToDb] Continuing despite error in test environment');
+            logger$9('[client/actors] [addModelsToDb] Continuing despite error in test environment');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
         else {
@@ -14320,6 +14624,102 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     return () => { };
 });
 
+const logger$8 = 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 = eas.DEFAULT_EAS_CHAIN_ID;
+async function readRecordedChainId(appDb) {
+    const rows = await appDb
+        .select({ value: appState.value })
+        .from(appState)
+        .where(drizzleOrm.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(drizzleOrm.and(drizzleOrm.isNotNull(seeds.uid), drizzleOrm.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 eas.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 ${eas.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) {
+        eas.configureEasReadChain('localDb', { chainId: localChainId });
+        logger$8('local DB holds chain %d', localChainId);
+        return;
+    }
+    if (eas.isEasReadChainConfigured()) {
+        const chainId = eas.getEasReadChainId();
+        await recordChainId(appDb, chainId);
+        eas.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 = eas.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.
+    eas.configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
+}
+
 const logger$7 = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     logger$7('saveConfig starting');
@@ -14402,6 +14802,8 @@ const saveConfig = xstate.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$7('[internal/actors] [saveConfig] Error saving config:', error);
@@ -18127,7 +18529,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-CDTOx5zi.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-D9FGaGuE.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -18144,7 +18546,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-XXcwj3hV.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-BiJIPLEL.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -19879,8 +20281,9 @@ class NodeFileManager {
     getFsSync() {
         return fs__namespace;
     }
-    async getContentUrlFromPath(_path) {
-        throw new Error('Not implemented');
+    /** Node has no blob URLs; a file:// URL keeps refResolvedDisplayValue meaningful for server callers. */
+    async getContentUrlFromPath(filePath) {
+        return url.pathToFileURL(path.resolve(filePath)).href;
     }
     async initializeFileSystem(_workingDir) {
         return; // No need to initialize file system in node
@@ -20046,7 +20449,7 @@ function resolveSdkDrizzleMigrationsDir(sdkRootDir) {
         })();
     // Also resolve relative to this module so temp-cwd tests / odd roots still find
     // packages/sdk/src/db/drizzle (or dist/db/drizzle after publish).
-    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-DM1WR83P.js', document.baseURI).href))));
+    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-CSNtEnbF.js', document.baseURI).href))));
     const candidates = [
         path.join(root, 'db', 'drizzle'), // production: sdkRoot is dist/
         path.join(root, 'dist', 'db', 'drizzle'), // sdk package root with built dist
@@ -20116,7 +20519,7 @@ class NodeDb {
         logger$1('[Db.prepareDb] running migrations from %s', outDir);
         await migrator.migrate(db, { migrationsFolder: outDir });
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-Bt4fzfIV.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-2XaN3b9S.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -20610,6 +21013,7 @@ exports.Image = Image;
 exports.Item = Item;
 exports.Item$1 = Item$1;
 exports.ItemProperty = ItemProperty;
+exports.ItemPropertySaveValidationError = ItemPropertySaveValidationError;
 exports.Json = Json;
 exports.List = List;
 exports.Model = Model;
@@ -20634,11 +21038,12 @@ exports.TPropertyDefs = TPropertyDefs;
 exports.TStorageType = TStorageType;
 exports.TValidationRules = TValidationRules;
 exports.Text = Text;
-exports.VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA = VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA;
+exports.VERSION_SCHEMA_UID = VERSION_SCHEMA_UID;
 exports.ZERO_BYTES32 = ZERO_BYTES32;
 exports.addModelsToDb = addModelsToDb$1;
 exports.addSchemaToDb = addSchemaToDb;
 exports.appState = appState;
+exports.assertLocalDbChain = assertLocalDbChain;
 exports.clearDestroySubscriptions = clearDestroySubscriptions;
 exports.commandExists = commandExists;
 exports.config = config;
@@ -20658,7 +21063,6 @@ exports.getAllAddressesFromDb = getAllAddressesFromDb;
 exports.getClient = getClient;
 exports.getContentHash = getContentHash;
 exports.getCorrectId = getCorrectId;
-exports.getEasSchemaForItemProperty = getEasSchemaForItemProperty;
 exports.getEasSchemaUidForModel = getEasSchemaUidForModel;
 exports.getItemData = getItemData;
 exports.getLatestPublishedVersionRow = getLatestPublishedVersionRow;
@@ -20670,8 +21074,12 @@ exports.getPropertyIdForModelAndName = getPropertyIdForModelAndName;
 exports.getRefValueType = getRefValueType;
 exports.htmlEmbeddedImageCoPublish = htmlEmbeddedImageCoPublish;
 exports.importJsonSchema = importJsonSchema;
+exports.isDataType = isDataType;
 exports.isInternalSchema = isInternalSchema;
+exports.isPublishedSeedRef = isPublishedSeedRef;
+exports.isStorageSeedRef = isStorageSeedRef;
 exports.listCompleteSchemaFiles = listCompleteSchemaFiles;
+exports.listRelationEasPropertyName = listRelationEasPropertyName;
 exports.loadAllSchemasFromDb = loadAllSchemasFromDb;
 exports.loadModelsFromDbForSchema = loadModelsFromDbForSchema;
 exports.loadSchemaFromFile = loadSchemaFromFile;
@@ -20682,13 +21090,16 @@ exports.modelUids = modelUids;
 exports.models = models$1;
 exports.normalizeDataType = normalizeDataType;
 exports.normalizeHexAddress = normalizeHexAddress;
+exports.normalizePropertyRecordSchema = normalizePropertyRecordSchema;
 exports.normalizePublisher = normalizePublisher;
+exports.normalizeRelationPropertyValue = normalizeRelationPropertyValue;
 exports.parseListPropertyValueFromStorage = parseListPropertyValueFromStorage;
 exports.parseMarkdownFrontmatter = parseMarkdownFrontmatter;
 exports.processSeedConfig = processSeedConfig;
 exports.properties = properties;
 exports.readJsonImportFile = readJsonImportFile;
 exports.resolveSdkDrizzleMigrationsDir = resolveSdkDrizzleMigrationsDir;
+exports.resolveSeedIdsFromRefString = resolveSeedIdsFromRefString;
 exports.resolveStorageNameToSchemaName = resolveStorageNameToSchemaName;
 exports.runDestroyLifecycle = runDestroyLifecycle;
 exports.runSeedInit = runSeedInit;
@@ -20704,7 +21115,8 @@ exports.toSnakeCase = toSnakeCase;
 exports.transformImportToSchemaFile = transformImportToSchemaFile;
 exports.unloadEntity = unloadEntity;
 exports.versions = versions;
+exports.waitForEasReadChain = waitForEasReadChain;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-DM1WR83P.js.map
+//# sourceMappingURL=index-CSNtEnbF.js.map