@seedprotocol/sdk 0.7.4-next.784.g879c6a3 → 0.7.4

package/dist/{Item-cq9VcsAY.js → Item-BUUFuywT.js}

@@ -1,14 +1,13 @@
 import { waitFor, fromCallback, setup, assign, stateIn, createActor, isMachineSnapshot } from 'xstate';
-import { n as normalizeDataType, E as BaseDb, C as versions, m as metadata, A as seeds, z as schemas, s as models, q as modelSchemas, aQ as getOwnedAddressesFromDb, a9 as ZERO_BYTES32, aB as normalizeAddressList, a0 as normalizeHexAddress, ay as getAddressesForItemsFilter, H as toSnakeCase$1, ad as INTERNAL_PROPERTY_NAMES, J as BaseFileManager, aS as getStorageTransactionIdForSeedUid, aT as convertTxIdToImage, i as isDataType, X as normalizePublisher, ax as ensureImageLocal, ap as ImageSize, aU as downloadTransactionIdWithDedupe, u as properties, M as ModelPropertyDataTypes, $ as generateId, ag as INTERNAL_DATA_TYPES, r as modelUids, L as resolveItemModelFileId, aV as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, aW as getDataTypeFromString, aX as getMimeType, am as INTERNAL_STORAGE_MODEL_FILE_IDS, V as getItemStorageSubdir, W as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, aY as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, a5 as getCorrectId, G as eventEmitter, ae as isStorageSeedRef } from './BasePathResolver-DxdS0wJ0.js';
+import { E as BaseDb, C as versions, m as metadata, A as seeds, F as resolveStorageNameToSchemaName, aV as toSchemaPropertyName, z as schemas, s as models, q as modelSchemas, aT as getOwnedAddressesFromDb, ac as ZERO_BYTES32, aE as normalizeAddressList, a0 as normalizeHexAddress, aB as getAddressesForItemsFilter, ag as INTERNAL_PROPERTY_NAMES, J as BaseFileManager, aW as getStorageTransactionIdForSeedUid, aX as convertTxIdToImage, i as isDataType, X as normalizePublisher, n as normalizeDataType, aY as getMetadataPropertyNamesForQuery, aA as ensureImageLocal, as as ImageSize, aZ as downloadTransactionIdWithDedupe, a_ as resolveMetadataRecord, u as properties, M as ModelPropertyDataTypes, $ as generateId, aj as INTERNAL_DATA_TYPES, r as modelUids, a1 as listRelationEasPropertyName, a2 as easPropertyNameForPublish, L as resolveItemModelFileId, a$ as getPropertyIdForSchemaFileId, K as getPropertyIdForModelAndName, a3 as toMetadataPropertyName, b0 as getDataTypeFromString, b1 as getMimeType, ap as INTERNAL_STORAGE_MODEL_FILE_IDS, V as getItemStorageSubdir, W as getItemStorageLocalFileName, g as normalizePropertyRecordSchema, b2 as listRelationStoragePropertyName, b3 as PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP, a8 as getCorrectId, H as eventEmitter, b4 as getAlternatePropertyNameForInstanceLookup, ah as isStorageSeedRef } from './BasePathResolver-DrzGVH9L.js';
 import { or, isNull, eq, max, count, and, getTableColumns, sql, desc, inArray, isNotNull, gt } from 'drizzle-orm';
-import pluralize from 'pluralize';
 import debug from 'debug';
 import { BehaviorSubject } from 'rxjs';
+import pluralize from 'pluralize';
 import { startCase, upperFirst, camelCase, orderBy } from 'lodash-es';
-import { toSnakeCase } from 'drizzle-orm/casing';
-import { isValidEasAttestationUid, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, cachedSchemaLookup, setSchemaUidForModel, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
+import { isValidEasAttestationUid, easName, isPlaceholderUid, BaseQueryClient, BaseEasClient, GET_SCHEMAS, getEasSchemaUidForSchemaDefinition, getSchemaUidForModelFromCache, setSchemaUidForModel, cachedSchemaLookup, getEasSchemaUidForExactDefinition } from '@seedprotocol/eas';
 import { fetchArweaveRawTextAcrossGateways } from '@seedprotocol/arweave';
-import { d as notifyFileSaved, f as withTabLock } from './tabEvents-BTzckWrN.js';
+import { d as notifyFileSaved, f as withTabLock } from './tabEvents-nBUq_1u1.js';
 import { modelPropertiesToObject } from './model-oHA3YhOd.js';
 
 /**
@@ -145,150 +144,6 @@ var publishConfig = /*#__PURE__*/Object.freeze({
     setUploadExecutor: setUploadExecutor
 });
 
-/** 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;
-    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;
-    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`.
- */
-function resolveStorageNameToSchemaName(propertySchemas, storagePropertyName) {
-    for (const [schemaKey, propDef] of Object.entries(propertySchemas)) {
-        if (normalizeDataType(propDef?.dataType) !== 'List')
-            continue;
-        const ref = propDef.ref || propDef.refModelName;
-        if (!ref)
-            continue;
-        const internalName = `${pluralize(schemaKey, 1)}${ref}Ids`;
-        if (internalName === storagePropertyName) {
-            return schemaKey;
-        }
-    }
-    return undefined;
-}
-/** Internal property names that never use Id-suffix metadata convention */
-const ID_SUFFIX_EXCLUDE = new Set(['storageTransactionId', 'transactionId']);
-/** Data types that store metadata with Id suffix in DB */
-const METADATA_ID_SUFFIX_TYPES = ['Image', 'File', 'Html', 'Relation'];
-/**
- * Whether this type uses Id suffix in metadata table.
- */
-function needsMetadataIdSuffix(dataType, refValueType) {
-    const dt = normalizeDataType(dataType);
-    const rvt = normalizeDataType(refValueType);
-    return (METADATA_ID_SUFFIX_TYPES.includes(dt) ||
-        METADATA_ID_SUFFIX_TYPES.includes(rvt));
-}
-/**
- * Canonical metadata property name for WRITES.
- * Use when creating/updating metadata.
- */
-function toMetadataPropertyName(propertyName, dataType, refValueType) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return propertyName;
-    if (propertyName.endsWith('Ids'))
-        return propertyName;
-    if (propertyName.endsWith('Id'))
-        return propertyName;
-    if (needsMetadataIdSuffix(dataType, refValueType)) {
-        return `${propertyName}Id`;
-    }
-    return propertyName;
-}
-/**
- * For READS: property names to include in OR query (both variants).
- * When dataType is undefined, includes all variants for safety (backwards compat with getPropertyData).
- */
-function getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return [propertyName];
-    if (propertyName.endsWith('Ids'))
-        return [propertyName];
-    if (propertyName.endsWith('Id')) {
-        const base = propertyName.slice(0, -2);
-        return [propertyName, base];
-    }
-    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
-        (dataType === undefined && refValueType === undefined);
-    if (needsId) {
-        return [propertyName, `${propertyName}Id`, `${propertyName}Ids`];
-    }
-    return [propertyName];
-}
-/**
- * Schema property name from metadata name (strip Id/Ids suffix).
- */
-function toSchemaPropertyName(propertyName) {
-    if (propertyName.endsWith('Ids'))
-        return propertyName.slice(0, -3);
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return undefined;
-}
-/**
- * Alternate property name for instance lookup (base <-> Id variant).
- */
-function getAlternatePropertyNameForInstanceLookup(propertyName) {
-    if (ID_SUFFIX_EXCLUDE.has(propertyName))
-        return undefined;
-    if (propertyName.endsWith('Id'))
-        return propertyName.slice(0, -2);
-    return `${propertyName}Id`;
-}
-/**
- * Resolve the best metadata record when multiple variants exist (base + Id).
- * For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename).
- */
-function resolveMetadataRecord(records, preferredPropertyName, dataType, refValueType) {
-    if (records.length === 0)
-        throw new Error('No records to resolve');
-    if (records.length === 1)
-        return records[0];
-    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
-        (dataType === undefined && refValueType === undefined);
-    // For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename)
-    if (needsId) {
-        const withRef = records.find((r) => r.refResolvedValue);
-        if (withRef)
-            return withRef;
-    }
-    // Also prefer by refSeedType when we need file ref
-    if (needsId) {
-        const byRefSeed = records.find((r) => r.refSeedType === 'image' ||
-            r.refSeedType === 'file' ||
-            r.refSeedType === 'html');
-        if (byRefSeed)
-            return byRefSeed;
-    }
-    // Fallback: prefer exact propertyName match, else first
-    return (records.find((r) => r.propertyName === preferredPropertyName) ?? records[0]);
-}
-
 /**
  * Proxy [[GetOwnProperty]] that stays compatible with the target.
  * Never overrides an own descriptor, never invents on a non-extensible target,
@@ -649,7 +504,7 @@ var metadataLatest = /*#__PURE__*/Object.freeze({
     getMetadataLatest: getMetadataLatest
 });
 
-const logger$8 = debug('seedSdk:item:actors:loadOrCreateItem');
+const logger$9 = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
  */
@@ -725,7 +580,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_0 = await import('./errors-Cl8rbtKR.js');
+        const _mod_0 = await import('./errors-DdWbxb_n.js');
         const _ns_0 = _mod_0.h;
         const { Model } = _ns_0;
         // Resolve Model and build property schemas (use getByNameAsync for models not yet in cache)
@@ -743,24 +598,24 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_1 = await import('./Schema-Dc5EA8Yb.js');
+                    const _mod_1 = await import('./Schema-Bf-jOLq0.js');
                     const _ns_1 = _mod_1.b;
                     const { Schema } = _ns_1;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
                         propertySchemas = schemaContext.models[modelName].properties;
-                        logger$8(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
+                        logger$9(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
                     }
                 }
                 catch (err) {
-                    logger$8(`Fallback Schema context failed for ${modelName}: ${err}`);
+                    logger$9(`Fallback Schema context failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_2 = await import('./ClientManager-De-vKHGe.js');
-                    const _ns_2 = _mod_2.K;
+                    const _mod_2 = await import('./ClientManager-Dfu4jcgm.js');
+                    const _ns_2 = _mod_2.L;
                     const { loadAllSchemasFromDb } = _ns_2;
                     const allSchemas = await loadAllSchemasFromDb();
                     for (const { schema: schemaFile } of allSchemas) {
@@ -769,22 +624,22 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const models = schemaFile.models;
                         if (models?.[modelName]?.properties) {
                             propertySchemas = models[modelName].properties;
-                            logger$8(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
+                            logger$9(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$8(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
+                    logger$9(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
                 try {
-                    const _mod_3 = await import('./ClientManager-De-vKHGe.js');
-                    const _ns_3 = _mod_3.K;
+                    const _mod_3 = await import('./ClientManager-Dfu4jcgm.js');
+                    const _ns_3 = _mod_3.L;
                     const { listCompleteSchemaFiles } = _ns_3;
-                    const _mod_4 = await import('./BasePathResolver-DxdS0wJ0.js');
-                    const _ns_4 = _mod_4.a$;
+                    const _mod_4 = await import('./BasePathResolver-DrzGVH9L.js');
+                    const _ns_4 = _mod_4.b7;
                     const { BaseFileManager } = _ns_4;
                     const schemaFiles = await listCompleteSchemaFiles();
                     for (const { filePath } of schemaFiles) {
@@ -794,17 +649,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                             continue;
                         if (schemaFile.models?.[modelName]?.properties) {
                             propertySchemas = schemaFile.models[modelName].properties;
-                            logger$8(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
+                            logger$9(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$8(`Fallback schema file scan failed for ${modelName}: ${err}`);
+                    logger$9(`Fallback schema file scan failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-CqnU-5i0.js');
+                const schemaMod = await import('./index-C61Rxy0F.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -816,12 +671,12 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 };
                 if (KNOWN_MODEL_FALLBACKS[modelName]) {
                     propertySchemas = KNOWN_MODEL_FALLBACKS[modelName];
-                    logger$8(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
+                    logger$9(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
                 }
             }
         }
         // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
-        const { normalizePropertyRecordSchema } = await import('./property-Brgr5RdT.js');
+        const { normalizePropertyRecordSchema } = await import('./property-zFPMtR3T.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
@@ -834,7 +689,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             try {
                 let propertyName = metaRow.propertyName;
                 if (!propertyName) {
-                    logger$8(`Metadata row missing propertyName, skipping`);
+                    logger$9(`Metadata row missing propertyName, skipping`);
                     continue;
                 }
                 const listSchemaKey = resolveStorageNameToSchemaName(propertySchemas, propertyName);
@@ -854,7 +709,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await import('./index-CqnU-5i0.js');
+                    const schemaMod = await import('./index-C61Rxy0F.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -884,14 +739,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$8(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
+                    logger$9(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$8(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
+                    logger$9(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
-                logger$8(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
+                logger$9(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
             }
         }
         // Create placeholder ItemProperty instances for model schema properties without metadata
@@ -914,17 +769,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$8(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
+                    logger$9(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
                 }
             }
             catch (error) {
-                logger$8(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
+                logger$9(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
             }
         }
-        logger$8(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
+        logger$9(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
     }
     catch (error) {
-        logger$8(`Error in createItemPropertyInstances: ${error}`);
+        logger$9(`Error in createItemPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
     return propertyInstances;
@@ -932,7 +787,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
 const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        logger$8(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$9(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -962,7 +817,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .limit(1);
         if (seedRecords.length === 0) {
             // Seed not found - this is a new item, will be created elsewhere
-            logger$8(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+            logger$9(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1005,7 +860,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .where(eq(seeds.localId, resolvedSeedLocalId))
             .limit(1);
         if (versionRecords.length === 0) {
-            logger$8(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$9(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1032,7 +887,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         // A seed whose versions are all revoked (fully unpublished) has no latest version but still has
         // its last property values; load those like any other item. Only a seed without versions stops here.
         if (!latestVersionLocalId && !versionRecord.versionsCount) {
-            logger$8(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$9(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -1064,7 +919,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .select()
             .from(metadataLatest)
             .where(eq(metadataLatest.rowNum, 1));
-        logger$8(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
+        logger$9(`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, modelScope);
@@ -1097,7 +952,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
         });
     };
     _loadOrCreateItem().catch((error) => {
-        logger$8(`Error in loadOrCreateItem: ${error}`);
+        logger$9(`Error in loadOrCreateItem: ${error}`);
         sendBack({
             type: 'loadOrCreateItemError',
             error: error instanceof Error ? error.message : String(error),
@@ -1105,7 +960,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$7 = debug('seedSdk:Item:runPublish');
+const logger$8 = debug('seedSdk:Item:runPublish');
 /**
  * Runs the publish for item.publish() by handing the item to the PublishExecutor that
  * @seedprotocol/publish registers, which uploads to Arweave and writes to EAS.
@@ -1134,7 +989,7 @@ const runPublish = fromCallback(({ sendBack, input: { context, item: itemFromEve
             sendBack({ type: 'publishSuccess' });
         }
         catch (error) {
-            logger$7('runPublish error:', error);
+            logger$8('runPublish error:', error);
             sendBack({ type: 'publishError', error: error instanceof Error ? error : new Error(String(error)) });
         }
     };
@@ -1413,7 +1268,7 @@ async function getLatestPublishedVersionRow(seedLocalId) {
     return null;
 }
 
-const logger$6 = debug('seedSdk:db:read:getItemData');
+const logger$7 = debug('seedSdk:db:read:getItemData');
 /**
  * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
  *
@@ -1429,7 +1284,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$6('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$7('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId || undefined;
@@ -1438,7 +1293,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     const { localId, uid, ...rest } = getTableColumns(seeds);
     const whereClauses = [];
     if (modelName) {
-        whereClauses.push(eq(seeds.type, toSnakeCase(modelName)));
+        whereClauses.push(eq(seeds.type, easName(modelName)));
     }
     if (seedUid) {
         whereClauses.push(eq(seeds.uid, seedUid));
@@ -1456,9 +1311,9 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .from(seeds)
         .where(and(...whereClauses))
         .limit(1);
-    logger$6('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
+    logger$7('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
     if (!seedRows || seedRows.length === 0) {
-        logger$6('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
+        logger$7('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
         return;
     }
     const seedRow = seedRows[0];
@@ -1484,7 +1339,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
             }
         }
         catch (error) {
-            logger$6('[getItemData] Error deriving schemaName:', error);
+            logger$7('[getItemData] Error deriving schemaName:', error);
         }
     }
     // Now get version data if it exists - query versions table directly
@@ -1857,11 +1712,11 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
         conditions.push(placeholderUidSql(seeds.uid));
     }
     if (modelName) {
-        conditions.push(eq(seeds.type, toSnakeCase(modelName)));
+        conditions.push(eq(seeds.type, easName(modelName)));
     }
     if (!modelFileId && schemaName && modelName) {
-        const _mod_5 = await import('./BasePathResolver-DxdS0wJ0.js');
-        const _ns_5 = _mod_5.b2;
+        const _mod_5 = await import('./BasePathResolver-DrzGVH9L.js');
+        const _ns_5 = _mod_5.ba;
         const { resolveModelRecord } = _ns_5;
         modelFileId = (await resolveModelRecord(modelName, { schemaName }))?.schemaFileId ?? undefined;
         if (!modelFileId)
@@ -1949,12 +1804,12 @@ async function getLatestVersionRow(seedLocalId) {
     return rows[0] ?? null;
 }
 
-const logger$5 = debug('seedSdk:ItemProperty:service:actors:waitForDb');
+const logger$6 = debug('seedSdk:ItemProperty:service:actors:waitForDb');
 const waitForDb = fromCallback(({ sendBack }) => {
     // Check immediately first
     const appDb = BaseDb.getAppDb();
     if (appDb) {
-        logger$5('Database is ready (immediate check)');
+        logger$6('Database is ready (immediate check)');
         sendBack({ type: 'waitForDbSuccess' });
         return;
     }
@@ -1966,31 +1821,31 @@ const waitForDb = fromCallback(({ sendBack }) => {
             const appDb = BaseDb.getAppDb();
             if (appDb) {
                 clearInterval(interval);
-                logger$5('Database is ready (after polling)');
+                logger$6('Database is ready (after polling)');
                 resolve();
             }
             else if (Date.now() - startTime > timeout) {
                 clearInterval(interval);
                 const error = new Error('Database not available after timeout');
-                logger$5(`Database wait timeout: ${error.message}`);
+                logger$6(`Database wait timeout: ${error.message}`);
                 reject(error);
             }
         }, 100);
     });
     _waitForDb
         .then(() => {
-        logger$5('Sending waitForDbSuccess event');
+        logger$6('Sending waitForDbSuccess event');
         sendBack({ type: 'waitForDbSuccess' });
     })
         .catch((error) => {
-        logger$5(`Error waiting for database: ${error}`);
+        logger$6(`Error waiting for database: ${error}`);
         sendBack({ type: 'waitForDbError', error: error.message });
     });
 });
 
 const getEasSchemaForItemProperty = async ({ schemaUid, propertyName, easDataType, }) => {
     try {
-        const propertyNameSnakeCase = toSnakeCase$1(propertyName);
+        const propertyNameSnakeCase = easName(propertyName);
         const isMissingSchemaUid = !schemaUid || schemaUid === 'null' || schemaUid === 'undefined';
         const queryClient = BaseQueryClient.getQueryClient();
         const easClient = BaseEasClient.getEasClient();
@@ -2135,7 +1990,7 @@ const getRelationValueData = async (propertyValue) => {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> resolveRelatedValue -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$4 = debug('seedSdk:property:actors:resolveRelatedValue');
+const logger$5 = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -2143,14 +1998,14 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CqnU-5i0.js');
+        const schemaMod = await import('./index-C61Rxy0F.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$4(`${propertyName} value is an array of seedUids`);
+            logger$5(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (typeof propertyValue === 'object') {
@@ -2162,7 +2017,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             parsedValue = JSON.parse(relationKey);
         }
         catch (error) {
-            logger$4(`${propertyName} value is not a JSON string.`);
+            logger$5(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(relationKey)) {
             const contentUrl = seedUidToContentUrl.get(relationKey);
@@ -2177,7 +2032,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
             return true;
         }
         if (Array.isArray(parsedValue)) {
-            logger$4(`${propertyName} value is a stringified array of seedUids`);
+            logger$5(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(relationKey);
@@ -2578,8 +2433,8 @@ async function readHtmlBodyFromChildStorageArweave(seedLocalId) {
         /* offline / bad tx id */
     }
     try {
-        const _mod_6 = await import('./BasePathResolver-DxdS0wJ0.js');
-        const _ns_6 = _mod_6.b4;
+        const _mod_6 = await import('./BasePathResolver-DrzGVH9L.js');
+        const _ns_6 = _mod_6.bc;
         const { downloadTransactionIdWithDedupe } = _ns_6;
         await downloadTransactionIdWithDedupe(txId);
         const retryFp = BaseFileManager.getFilesPath('html', `${seedLocalId}.html`);
@@ -2628,7 +2483,7 @@ async function readHtmlBodyForStorageSeedPropertyValue(propertyValue) {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$3 = debug('seedSdk:property:actors:hydrateFromDb');
+const logger$4 = debug('seedSdk:property:actors:hydrateFromDb');
 const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
     if (!propertyNameRaw) {
@@ -2639,7 +2494,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CqnU-5i0.js');
+        const schemaMod = await import('./index-C61Rxy0F.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -2745,7 +2600,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                     }
                 }
                 catch (e) {
-                    logger$3('[hydrateFromDb] Image file resolution error', e);
+                    logger$4('[hydrateFromDb] Image file resolution error', e);
                 }
             }
         }
@@ -2778,7 +2633,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             catch (e) {
-                logger$3('[hydrateFromDb] File resolution error', e);
+                logger$4('[hydrateFromDb] File resolution error', e);
             }
         }
         if (propertyRecordSchema &&
@@ -2881,11 +2736,11 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$2 = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$3 = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$2(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$3(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -2920,12 +2775,12 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
             const modelNameForNew = context.modelName;
             if (modelNameForNew) {
                 try {
-                    const _mod_7 = await import('./errors-Cl8rbtKR.js');
+                    const _mod_7 = await import('./errors-DdWbxb_n.js');
                     const _ns_7 = _mod_7.h;
                     const { Model } = _ns_7;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-                    const _mod_8 = await import('./BasePathResolver-DxdS0wJ0.js');
-                    const _ns_8 = _mod_8.b2;
+                    const _mod_8 = await import('./BasePathResolver-DrzGVH9L.js');
+                    const _ns_8 = _mod_8.ba;
                     const { resolveItemModelFileId } = _ns_8;
                     const normalizedModelName = upperFirst(camelCase(modelNameForNew));
                     const itemModelFileId = await resolveItemModelFileId({
@@ -2935,21 +2790,21 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                     });
                     let model = await Model.resolveAsync(normalizedModelName, { modelFileId: itemModelFileId });
                     if (!model?.properties?.length && !itemModelFileId) {
-                        model = Model.findByModelType(toSnakeCase(modelNameForNew));
+                        model = Model.findByModelType(easName(modelNameForNew));
                     }
                     if (model?.properties?.length) {
                         const schemas = modelPropertiesToObject(model.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$2(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$3(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$2(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$3(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$2(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$3(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -2978,8 +2833,8 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         // It ends up in the context below, and later lookups by name (Model.getByName) can't match it.
         const modelName = context.modelName || (metadataRecord.modelType ? upperFirst(camelCase(metadataRecord.modelType)) : undefined);
         // Model names are only unique per schema: pin lookups to the item's own model row.
-        const _mod_9 = await import('./BasePathResolver-DxdS0wJ0.js');
-        const _ns_9 = _mod_9.b2;
+        const _mod_9 = await import('./BasePathResolver-DrzGVH9L.js');
+        const _ns_9 = _mod_9.ba;
         const { resolveItemModelFileId, resolveModelRecord } = _ns_9;
         const modelFileId = await resolveItemModelFileId({
             modelFileId: context.modelFileId,
@@ -3023,7 +2878,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                             required: propRecord.required ?? undefined,
                         };
                         // Validation rules (enum, pattern, ...) aren't in the properties table
-                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CDRitiiK.js');
+                        const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CeFVhdQg.js');
                         const validation = await resolvePropertyValidationRules(normalizedModelName, propertyName, {
                             modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                         });
@@ -3034,13 +2889,13 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (error) {
-                logger$2(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$3(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
         if (!propertyRecordSchema && modelName) {
             try {
-                const _mod_10 = await import('./errors-Cl8rbtKR.js');
+                const _mod_10 = await import('./errors-DdWbxb_n.js');
                 const _ns_10 = _mod_10.h;
                 const { Model } = _ns_10;
                 const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -3048,18 +2903,18 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 // Try PascalCase first ("post" -> "Post"); then findByModelType for names with spaces ("new_model" -> "New model")
                 let model = Model.resolve(normalizedModelName, { modelFileId });
                 if (!model?.properties?.length && !modelFileId) {
-                    model = Model.findByModelType(toSnakeCase(modelName));
+                    model = Model.findByModelType(easName(modelName));
                 }
                 if (model?.properties?.length) {
                     const schemas = modelPropertiesToObject(model.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$2(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$3(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$2(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$3(`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)
@@ -3100,7 +2955,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$2(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$3(`Failed to read Html file for ${propertyName}: ${e}`);
             }
         }
         // Covers missing ref row, wrong ref, or DB dataType casing "html" (handled by isHtml above).
@@ -3158,7 +3013,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         });
                     }
                     catch (e) {
-                        logger$2(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
+                        logger$3(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
                     }
                 }
             }
@@ -3180,7 +3035,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$2(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$3(`Failed to resolve Image file for ${propertyName}: ${e}`);
             }
         }
         const isFile = refSeedType === 'file' ||
@@ -3199,7 +3054,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$2(`Failed to resolve File for ${propertyName}: ${e}`);
+                logger$3(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -3232,7 +3087,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$2(`Error in loadOrCreateProperty: ${error}`);
+        logger$3(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -3262,10 +3117,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$1 = debug('seedSdk:write:updateItemPropertyValue');
+const logger$2 = 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$1(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$2(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     // Every write below binds parameters: store the value as given (no SQL escaping).
@@ -3317,7 +3172,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$1(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$2(`[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
@@ -3474,9 +3329,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CqnU-5i0.js');
+        const schemaMod = await import('./index-C61Rxy0F.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-BNYMacsx.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -3642,36 +3497,17 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     });
 });
 
+const logger$1 = debug('seedSdk:db:read:getSchemaUidForModel');
+/**
+ * EAS schema UID of a model's seeds: the in-memory cache, then `model_uids` (written from EAS by
+ * startup and sync), then EAS itself. The DB comes before EAS so creating items and saving
+ * images, files and Html bodies works offline. A failed EAS request (offline) counts as "no UID":
+ * the seed is created without one and publish looks it up again.
+ */
 const getEasSchemaUidForModel = async (modelName) => {
     const cached = getSchemaUidForModelFromCache(modelName);
     if (cached)
         return cached;
-    const modeType = modelName.toLowerCase();
-    // Misses are cached too (most local models have no EAS schema); the DB fallback below still runs.
-    const easSchemaUid = await cachedSchemaLookup(`model:${modeType}`, async () => {
-        const queryClient = BaseQueryClient.getQueryClient();
-        const easClient = BaseEasClient.getEasClient();
-        const modelSchemaQuery = await queryClient.fetchQuery({
-            queryKey: [`getEasSchemaUidForModel`, modeType],
-            queryFn: async () => easClient.request(GET_SCHEMAS, {
-                where: {
-                    schemaNames: {
-                        some: {
-                            name: {
-                                equals: modeType,
-                            },
-                        },
-                    },
-                },
-            }),
-        });
-        return modelSchemaQuery.schemas[0]?.id;
-    });
-    if (easSchemaUid) {
-        setSchemaUidForModel({ modelName, schemaUid: easSchemaUid });
-        return easSchemaUid;
-    }
-    // Fallback: use schema UID from local DB when EAS has no schema (e.g. test schemas)
     const appDb = BaseDb.getAppDb();
     if (appDb) {
         const row = await appDb
@@ -3686,6 +3522,38 @@ const getEasSchemaUidForModel = async (modelName) => {
             return uid;
         }
     }
+    const modeType = modelName.toLowerCase();
+    let easSchemaUid;
+    try {
+        // Misses are cached too (most local models have no EAS schema).
+        easSchemaUid = await cachedSchemaLookup(`model:${modeType}`, async () => {
+            const queryClient = BaseQueryClient.getQueryClient();
+            const easClient = BaseEasClient.getEasClient();
+            const modelSchemaQuery = await queryClient.fetchQuery({
+                queryKey: [`getEasSchemaUidForModel`, modeType],
+                queryFn: async () => easClient.request(GET_SCHEMAS, {
+                    where: {
+                        schemaNames: {
+                            some: {
+                                name: {
+                                    equals: modeType,
+                                },
+                            },
+                        },
+                    },
+                }),
+            });
+            return modelSchemaQuery.schemas[0]?.id;
+        });
+    }
+    catch (error) {
+        logger$1(`EAS schema lookup for model ${modelName} failed (offline?): ${error}`);
+        return undefined;
+    }
+    if (easSchemaUid) {
+        setSchemaUidForModel({ modelName, schemaUid: easSchemaUid });
+        return easSchemaUid;
+    }
     return undefined;
 };
 
@@ -3740,7 +3608,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         metadataValues.publisher = publisher;
     }
     if (!metadataValues.modelType && metadataValues.modelName) {
-        metadataValues.modelType = toSnakeCase(metadataValues.modelName);
+        metadataValues.modelType = easName(metadataValues.modelName);
     }
     // List of Relation rows live under the storage name (authors → authorIdentityIds), never the schema key.
     if (metadataValues.propertyName) {
@@ -3775,7 +3643,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-BNYMacsx.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -3797,7 +3665,8 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
                 const dataTypeKey = normalizeDataType(propertyRecordSchema.dataType);
                 const easDataType = INTERNAL_DATA_TYPES[dataTypeKey]?.eas;
                 if (easDataType) {
-                    const propertyNameSnakeCase = toSnakeCase(metadataValues.propertyName);
+                    // The name publish registers (ADR 0008): a single relation's key, not its authorId storage name.
+                    const propertyNameSnakeCase = easPropertyNameForPublish(metadataValues.propertyName, propertyRecordSchema);
                     // Cached, including misses: every item of a model looks up the same property schemas.
                     const schemaUid = await getEasSchemaUidForExactDefinition(`${easDataType} ${propertyNameSnakeCase}`);
                     if (schemaUid) {
@@ -4387,7 +4256,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-CqnU-5i0.js');
+        const schemaMod = await import('./index-C61Rxy0F.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -5106,11 +4975,11 @@ const getPropertyData = async ({ propertyName, seedLocalId, seedUid, modelName,
     let names = [...getMetadataPropertyNamesForQuery(propertyName)];
     if (modelName) {
         try {
-            const _mod_11 = await import('./errors-Cl8rbtKR.js');
+            const _mod_11 = await import('./errors-DdWbxb_n.js');
             const _ns_11 = _mod_11.h;
             const { Model } = _ns_11;
-            const _mod_12 = await import('./BasePathResolver-DxdS0wJ0.js');
-            const _ns_12 = _mod_12.b2;
+            const _mod_12 = await import('./BasePathResolver-DrzGVH9L.js');
+            const _ns_12 = _mod_12.ba;
             const { resolveItemModelFileId } = _ns_12;
             // Model names are only unique per schema: use the seed's own model when it is recorded.
             const modelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
@@ -5310,8 +5179,8 @@ const HTML_PROP_SEED_UID_RE = /^0x[a-fA-F0-9]{64}$/;
  */
 const resolvePropertyRecordSchemaFromSchemaData = async (modelName, propertyName, modelType, schemaName) => {
     try {
-        const _mod_13 = await import('./ClientManager-De-vKHGe.js');
-        const _ns_13 = _mod_13.K;
+        const _mod_13 = await import('./ClientManager-Dfu4jcgm.js');
+        const _ns_13 = _mod_13.L;
         const { loadAllSchemasFromDb } = _ns_13;
         const allSchemas = await loadAllSchemasFromDb();
         const modelNameAlt = modelType ? upperFirst(camelCase(modelType)) : '';
@@ -5364,12 +5233,12 @@ hints = {}) => {
         return undefined;
     }
     try {
-        const _mod_14 = await import('./errors-Cl8rbtKR.js');
+        const _mod_14 = await import('./errors-DdWbxb_n.js');
         const _ns_14 = _mod_14.h;
         const { Model } = _ns_14;
         const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
-        const _mod_15 = await import('./BasePathResolver-DxdS0wJ0.js');
-        const _ns_15 = _mod_15.b2;
+        const _mod_15 = await import('./BasePathResolver-DrzGVH9L.js');
+        const _ns_15 = _mod_15.ba;
         const { resolveItemModelFileId } = _ns_15;
         const modelFileId = await resolveItemModelFileId(hints);
         let model = modelFileId
@@ -5528,7 +5397,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-CqnU-5i0.js');
+            const schemaMod = await import('./index-C61Rxy0F.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -5699,7 +5568,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_16 = await import('./index-DAl9U4rn.js');
+                const _mod_16 = await import('./index-7y2f_iQz.js');
                 const _ns_16 = _mod_16.s;
                 const seedSchemaMod = _ns_16;
                 const { metadata } = seedSchemaMod;
@@ -5923,8 +5792,8 @@ class ItemProperty {
             const ctx = this._service.getSnapshot().context;
             let modelFileId;
             try {
-                const _mod_17 = await import('./BasePathResolver-DxdS0wJ0.js');
-                const _ns_17 = _mod_17.b2;
+                const _mod_17 = await import('./BasePathResolver-DrzGVH9L.js');
+                const _ns_17 = _mod_17.ba;
                 const { resolveItemModelFileId } = _ns_17;
                 modelFileId = await resolveItemModelFileId({
                     modelFileId: ctx.modelFileId,
@@ -6286,8 +6155,8 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         const seenNormalized = new Set();
-        const _mod_18 = await import('./BasePathResolver-DxdS0wJ0.js');
-        const _ns_18 = _mod_18.b2;
+        const _mod_18 = await import('./BasePathResolver-DrzGVH9L.js');
+        const _ns_18 = _mod_18.ba;
         const { resolveItemModelFileId } = _ns_18;
         const itemModelFileId = await resolveItemModelFileId({ seedLocalId, seedUid });
         for (const data of propertiesData) {
@@ -6304,7 +6173,7 @@ class ItemProperty {
             }
             else if (baseName) {
                 try {
-                    const _mod_19 = await import('./errors-Cl8rbtKR.js');
+                    const _mod_19 = await import('./errors-DdWbxb_n.js');
                     const _ns_19 = _mod_19.h;
                     const { Model } = _ns_19;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6321,7 +6190,7 @@ class ItemProperty {
             }
             if (modelName && propertyName) {
                 try {
-                    const _mod_20 = await import('./errors-Cl8rbtKR.js');
+                    const _mod_20 = await import('./errors-DdWbxb_n.js');
                     const _ns_20 = _mod_20.h;
                     const { Model } = _ns_20;
                     const { modelPropertiesToObject } = await import('./model-oHA3YhOd.js');
@@ -6653,7 +6522,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_21 = await import('./index-DAl9U4rn.js');
+                    const _mod_21 = await import('./index-7y2f_iQz.js');
                     const _ns_21 = _mod_21.s;
                     const seedSchemaMod = _ns_21;
                     const { metadata } = seedSchemaMod;
@@ -6696,9 +6565,9 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     if (!modelName) {
         throw new Error('A model name is required for createNewItem');
     }
-    const seedType = toSnakeCase(modelName);
+    const seedType = easName(modelName);
     // Dynamic import to break circular dependency
-    const _mod_22 = await import('./errors-Cl8rbtKR.js');
+    const _mod_22 = await import('./errors-DdWbxb_n.js');
     const _ns_22 = _mod_22.h;
     const modelMod = _ns_22;
     const { Model } = modelMod;
@@ -6706,7 +6575,7 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     const propertySchemas = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
     modelFileId ?? (modelFileId = model?.id);
     const newSeedId = await createSeed({ type: seedType, modelFileId });
-    const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase(modelName) });
+    const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: easName(modelName) });
     // Build set of all properties to create metadata for: union of model schema + propertyData
     // This ensures we create metadata for ALL model properties even when creating with no initial values
     // (fixes first-item persistence: loadOrCreateItem needs metadata rows to run createItemPropertyInstances)
@@ -6881,7 +6750,7 @@ const getModel = () => {
         // the fragile `import(...).then(n => n.X)` chunk-namespace pattern.
         if (!modelImportPromise) {
             modelImportPromise = (async () => {
-                const _mod_23 = await import('./errors-Cl8rbtKR.js');
+                const _mod_23 = await import('./errors-DdWbxb_n.js');
                 const _ns_23 = _mod_23.h;
                 const mod = _ns_23;
                 ModelClass = mod.Model;
@@ -7049,12 +6918,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-DJ1UPh7i.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-J-143iSV.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const _mod_24 = await import('./getPublishPayload-C278kK9P.js');
+            const _mod_24 = await import('./getPublishPayload-DPy-uMrR.js');
             const _ns_24 = _mod_24.g;
             const getPublishPayloadMod = _ns_24;
             const { getPublishPayload } = getPublishPayloadMod;
@@ -7590,8 +7459,8 @@ class Item {
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Model names are only unique per schema: resolve the exact models row from the most specific scope.
-            const _mod_25 = await import('./BasePathResolver-DxdS0wJ0.js');
-            const _ns_25 = _mod_25.b2;
+            const _mod_25 = await import('./BasePathResolver-DrzGVH9L.js');
+            const _ns_25 = _mod_25.ba;
             const { resolveModelRecord } = _ns_25;
             const modelRecord = await resolveModelRecord(props.modelName, {
                 modelFileId: props.modelFileId ?? modelInstance?.id,
@@ -7599,7 +7468,7 @@ class Item {
             });
             const modelRecords = modelRecord ? [modelRecord] : [];
             if (!modelRecord) {
-                const _mod_26 = await import('./errors-Cl8rbtKR.js');
+                const _mod_26 = await import('./errors-DdWbxb_n.js');
                 const _ns_26 = _mod_26.j;
                 const { UnknownModelError } = _ns_26;
                 throw new UnknownModelError(props.modelName, schemaName ?? modelInstance?.schemaName);
@@ -7610,11 +7479,11 @@ class Item {
             // Scope the constructor's Model lookup to this model's schema (as getItemData does on reload),
             // so a same-named model cached from another schema can't supply the property set.
             if (modelRecord && !props.schemaName) {
-                const _mod_27 = await import('./BasePathResolver-DxdS0wJ0.js');
-                const _ns_27 = _mod_27.b1;
+                const _mod_27 = await import('./BasePathResolver-DrzGVH9L.js');
+                const _ns_27 = _mod_27.b9;
                 const { modelSchemas } = _ns_27;
-                const _mod_28 = await import('./BasePathResolver-DxdS0wJ0.js');
-                const _ns_28 = _mod_28.b0;
+                const _mod_28 = await import('./BasePathResolver-DrzGVH9L.js');
+                const _ns_28 = _mod_28.b8;
                 const { schemas: schemasTable } = _ns_28;
                 const schemaRows = await db
                     .select({ schemaName: schemasTable.name })
@@ -7972,7 +7841,7 @@ class Item {
         if (!appDb || Item.instanceCache.size === 0) {
             return;
         }
-        const _mod_29 = await import('./index-DAl9U4rn.js');
+        const _mod_29 = await import('./index-7y2f_iQz.js');
         const _ns_29 = _mod_29.s;
         const { metadata } = _ns_29;
         const { eq, and } = await import('drizzle-orm');
@@ -8135,11 +8004,11 @@ class Item {
     }
     /** Throws ItemCreateValidationError for unknown keys and values that break their property's rules. */
     static async assertValidCreateValues(props, propertyNames, dataTypeByPropertyName, skipKeys) {
-        const _mod_30 = await import('./errors-Cl8rbtKR.js');
+        const _mod_30 = await import('./errors-DdWbxb_n.js');
         const _ns_30 = _mod_30.j;
         const { ItemCreateValidationError } = _ns_30;
-        const { getPropertySchema } = await import('./property-Brgr5RdT.js');
-        const { SchemaValidationService } = await import('./SchemaValidationService-DViJ056F.js');
+        const { getPropertySchema } = await import('./property-zFPMtR3T.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-BNYMacsx.js');
         const validationService = new SchemaValidationService();
         const modelName = props.modelName;
         const known = new Set(propertyNames);
@@ -8176,7 +8045,7 @@ class Item {
                     // Not JSON: validated as given, and rejected as a non-array
                 }
             }
-            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CDRitiiK.js');
+            const { resolvePropertyValidationRules } = await import('./propertyValidationRules-CeFVhdQg.js');
             const rules = propertySchema?.validation ??
                 (await resolvePropertyValidationRules(modelName, key, {
                     modelFileId: props.modelFileId,
@@ -8507,7 +8376,7 @@ class Item {
                 itemActor.send(event);
             };
             try {
-                const _mod_31 = await import('./index-DAl9U4rn.js');
+                const _mod_31 = await import('./index-7y2f_iQz.js');
                 const _ns_31 = _mod_31.s;
                 const seedSchemaMod = _ns_31;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -8871,5 +8740,5 @@ var Item$1 = /*#__PURE__*/Object.freeze({
     Item: Item
 });
 
-export { getInvariantSafePropertyDescriptor as $, getGetPublisherForNewSeeds as A, getMetadataLatest as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getPublishExecutor as E, getRevokeExecutor as F, getUploadExecutor as G, getVersionData$1 as H, Item as I, isLocalUnsealedDraft as J, isSeedRowOwned as K, localUnsealedDraftSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, ownedPublisherSql as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, ownedSeedsSql as Q, pickLatestMetadataRowPerProperty as R, placeholderUidSql as S, propertyMachine as T, publisherInAddressListSql as U, publisherIsInOwnedSet as V, setAdditionalSyncAddresses as W, setGetPublisherForNewSeeds as X, setPublishExecutor as Y, setRevokeExecutor as Z, setUploadExecutor as _, chunkValues as a, clearDestroySubscriptions as a0, unloadEntity as a1, ClientManagerEvents as a2, withLockedItemStorageRow as a3, getItemStorageFilePath as a4, writeItemStorageFile as a5, resolvePublisherFromSeedRow as a6, getPropertyData$1 as a7, Item$1 as a8, rowsPerInsert as b, compareMetadataRowsLatestFirst as c, getGetAdditionalSyncAddresses as d, ItemProperty as e, ItemPropertySaveValidationError as f, getItemData as g, assertItemOwned as h, isItemOwned as i, getEasSchemaUidForModel as j, getLatestPublishedVersionRow as k, listRelationEasPropertyName as l, isVersionRevoked as m, waitForEntityIdle as n, createReactiveProxy as o, parseListPropertyValueFromStorage as p, findEntity as q, resolveStorageNameToSchemaName as r, selectInBatches as s, forceRemoveFromCaches as t, runDestroyLifecycle as u, isPublishedMetadataRow as v, writeInBatches as w, MachineIds as x, createNewItem as y, getEasSchemaForItemProperty as z };
-//# sourceMappingURL=Item-cq9VcsAY.js.map
+export { unloadEntity as $, getPublishExecutor as A, getRevokeExecutor as B, ClientManagerState as C, DEFAULT_READY_TIMEOUT_MS as D, getUploadExecutor as E, getVersionData$1 as F, isLocalUnsealedDraft as G, isSeedRowOwned as H, Item as I, localUnsealedDraftSql as J, ownedPublisherSql as K, ownedSeedsSql as L, METADATA_LATEST_FIRST_ORDER_SQL as M, pickLatestMetadataRowPerProperty as N, OwnershipError as O, PUBLISH_NOT_CONFIGURED_MESSAGE as P, placeholderUidSql as Q, propertyMachine as R, publisherInAddressListSql as S, publisherIsInOwnedSet as T, setAdditionalSyncAddresses as U, setGetPublisherForNewSeeds as V, setPublishExecutor as W, setRevokeExecutor as X, setUploadExecutor as Y, getInvariantSafePropertyDescriptor as Z, clearDestroySubscriptions as _, chunkValues as a, ClientManagerEvents as a0, withLockedItemStorageRow as a1, getItemStorageFilePath as a2, writeItemStorageFile as a3, resolvePublisherFromSeedRow as a4, getPropertyData$1 as a5, Item$1 as a6, getGetAdditionalSyncAddresses as b, compareMetadataRowsLatestFirst as c, ItemProperty as d, ItemPropertySaveValidationError as e, assertItemOwned as f, getItemData as g, getEasSchemaUidForModel as h, isItemOwned as i, getLatestPublishedVersionRow as j, isVersionRevoked as k, waitForEntityIdle as l, createReactiveProxy as m, findEntity as n, forceRemoveFromCaches as o, parseListPropertyValueFromStorage as p, runDestroyLifecycle as q, rowsPerInsert as r, selectInBatches as s, isPublishedMetadataRow as t, MachineIds as u, createNewItem as v, writeInBatches as w, getEasSchemaForItemProperty as x, getGetPublisherForNewSeeds as y, getMetadataLatest as z };
+//# sourceMappingURL=Item-BUUFuywT.js.map