@seedprotocol/sdk 0.4.20 → 0.4.21

package/dist/{index-C1HlP_fU.js → index-BrD_NNaX.js}

@@ -1,6 +1,6 @@
 import { waitFor, fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
 import { sqliteTable, integer, text, unique, int, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
-import { relations, eq, and, isNull, isNotNull, not, or, max, count, getTableColumns, sql, inArray, gt, desc } from 'drizzle-orm';
+import { relations, and, eq, isNull, isNotNull, not, or, max, count, getTableColumns, sql, desc, inArray, gt } from 'drizzle-orm';
 import { customAlphabet } from 'nanoid';
 import * as nanoIdDictionary from 'nanoid-dictionary';
 import debug from 'debug';
@@ -304,6 +304,8 @@ const INTERNAL_DATA_TYPES = {
         eas: 'bytes32',
     },
 };
+/** Full property names ending in `Id` that must not be stripped to a “base” name for `allProperties` keys. */
+const PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP = new Set(['storageTransactionId']);
 const INTERNAL_PROPERTY_NAMES = [
     'localId',
     'uid',
@@ -388,6 +390,7 @@ var constants = /*#__PURE__*/Object.freeze({
     INTERNAL_PROPERTY_NAMES: INTERNAL_PROPERTY_NAMES,
     INTERNAL_SCHEMA_IDS: INTERNAL_SCHEMA_IDS,
     get ImageSize () { return ImageSize; },
+    PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP: PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP,
     SCHEMA_NJK: SCHEMA_NJK,
     SCHEMA_TS: SCHEMA_TS,
     SEED_CONFIG_FALLBACKS: SEED_CONFIG_FALLBACKS,
@@ -567,14 +570,19 @@ function getUploadApiArweaveDataUrl(baseUrl, txOrDataItemId) {
     const id = encodeURIComponent(txOrDataItemId);
     return `${base}/api/upload/arweave/data/${id}`;
 }
+const DEFAULT_UPLOAD_STATUS_TIMEOUT_MS = 45000;
 /**
  * Presence check against the upload API data route (same semantics as
  * {@link BaseArweaveClient.getTransactionStatus} for gateways: 200 = present, 404 = missing).
  */
-async function getUploadPipelineTransactionStatus(uploadApiBaseUrl, txOrDataItemId) {
+async function getUploadPipelineTransactionStatus(uploadApiBaseUrl, txOrDataItemId, options) {
     const url = getUploadApiArweaveDataUrl(uploadApiBaseUrl, txOrDataItemId);
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_UPLOAD_STATUS_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const response = await fetch(url);
+        const response = await fetch(url, { signal: controller.signal });
+        clearTimeout(timeoutId);
         if (response.status === 404) {
             return { status: 404, confirmed: null };
         }
@@ -586,7 +594,11 @@ async function getUploadPipelineTransactionStatus(uploadApiBaseUrl, txOrDataItem
         }
         return { status: 200, confirmed: null };
     }
-    catch {
+    catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === 'AbortError') {
+            return { status: 504, confirmed: null };
+        }
         return { status: 500, confirmed: null };
     }
 }
@@ -728,8 +740,18 @@ async function waitForEntityIdle(entity, options = {}) {
     const { timeout = 5000, throwOnError = true } = options;
     const service = entity.getService();
     const currentSnapshot = service.getSnapshot();
+    const isSnapshotIdle = (snapshot) => {
+        if (!('value' in snapshot) || snapshot.value !== 'idle') {
+            return false;
+        }
+        // ItemProperty: same condition as ItemProperty.save() — nested "saving" uses object state values
+        if (snapshot.context?.isSaving) {
+            return false;
+        }
+        return true;
+    };
     // Check current state first - if already idle, return immediately
-    if ('value' in currentSnapshot && currentSnapshot.value === 'idle') {
+    if (isSnapshotIdle(currentSnapshot)) {
         return;
     }
     if ('value' in currentSnapshot && currentSnapshot.value === 'error') {
@@ -746,13 +768,18 @@ async function waitForEntityIdle(entity, options = {}) {
                 }
                 return true; // Accept error state if not throwing
             }
-            return 'value' in snapshot && snapshot.value === 'idle';
+            return isSnapshotIdle(snapshot);
         }, { timeout });
     }
     catch (error) {
         if (error.message === 'Entity failed to load') {
             throw error;
         }
+        const msg = typeof error?.message === 'string' ? error.message : '';
+        const isWaitForTimeout = msg.includes('Timeout') || msg.toLowerCase().includes('timed out');
+        if (!throwOnError && isWaitForTimeout) {
+            return;
+        }
         throw new Error(`Entity loading timeout after ${timeout}ms`);
     }
 }
@@ -904,6 +931,11 @@ const TStorageType = Type.Union([
     Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
     Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
 ]);
+/** How publish handles `data:image/*` URIs inside Html storage. Only applies when `dataType === 'Html'`. */
+const THtmlEmbeddedDataUriPolicy = Type.Union([
+    Type.Literal('materialize'),
+    Type.Literal('preserve'),
+]);
 const TProperty = Type.Object({
     id: Type.Optional(Type.String()), // schemaFileId (string) - public ID
     _dbId: Type.Optional(Type.Number()), // Database integer ID - internal only
@@ -921,6 +953,8 @@ const TProperty = Type.Object({
     filenameSuffix: Type.Optional(Type.String()),
     validation: Type.Optional(TValidationRules),
     required: Type.Optional(Type.Boolean()),
+    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
+    htmlEmbeddedDataUriPolicy: Type.Optional(THtmlEmbeddedDataUriPolicy),
 });
 const TPropertyConstructor = Type.Function([
     Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
@@ -928,6 +962,14 @@ const TPropertyConstructor = Type.Function([
     Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
 ], TProperty);
 const TPropertyDefs = Type.Record(TPropertyDataType, TPropertyConstructor);
+function htmlPropertyFactory(opts) {
+    return {
+        dataType: ModelPropertyDataTypes.Html,
+        ...(opts?.htmlEmbeddedDataUriPolicy
+            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
+            : {}),
+    };
+}
 const Property = {
     Text: (storageType, localStorageDir, filenameSuffix) => ({
         dataType: ModelPropertyDataTypes.Text,
@@ -960,7 +1002,8 @@ const Property = {
     Image: () => ({ dataType: ModelPropertyDataTypes.Image }),
     Boolean: () => ({ dataType: ModelPropertyDataTypes.Boolean }),
     Date: () => ({ dataType: ModelPropertyDataTypes.Date }),
-    Html: () => ({ dataType: ModelPropertyDataTypes.Html }),
+    Html: htmlPropertyFactory,
+    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
 };
 const PropertyMetadataKey = Symbol('property');
 const PropertyConstructor = (propertyType) => {
@@ -979,6 +1022,7 @@ const Relation = (ref, refValueType, required) => PropertyConstructor(Property.R
 const List = (refValueType, ref) => PropertyConstructor(Property.List(refValueType, ref));
 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
@@ -1136,24 +1180,499 @@ function normalizeRelationPropertyValue(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();
+        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 {};
+}
+
+const seeds = sqliteTable('seeds', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    schemaUid: text('schema_uid'),
+    type: text('type'),
+    publisher: text('publisher'),
+    attestationRaw: text('attestation_raw'),
+    attestationCreatedAt: int('attestation_created_at'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    _markedForDeletion: int('_marked_for_deletion'),
+    revokedAt: int('revoked_at'),
+});
+
+const versions = sqliteTable('versions', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    seedLocalId: text('seed_local_id'),
+    seedUid: text('seed_uid'),
+    seedType: text('seed_type'),
+    note: text('note'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    attestationCreatedAt: int('attestation_created_at'),
+    attestationRaw: text('attestation_raw'),
+    publisher: text('publisher'),
+});
+
+const metadata$1 = sqliteTable('metadata', {
+    localId: text('local_id').unique(),
+    uid: text('uid'),
+    propertyId: integer('property_id').references(() => properties.id),
+    propertyName: text('property_name'),
+    propertyValue: text('property_value'),
+    schemaUid: text('schema_uid'),
+    modelType: text('model_type'),
+    seedLocalId: text('seed_local_id'),
+    seedUid: text('seed_uid'),
+    versionLocalId: text('version_local_id'),
+    versionUid: text('version_uid'),
+    easDataType: text('eas_data_type'),
+    refValueType: text('ref_value_type'),
+    refModelUid: text('ref_schema_uid'),
+    refSeedType: text('ref_seed_type'),
+    refResolvedValue: text('ref_resolved_value'),
+    refResolvedDisplayValue: text('ref_resolved_display_value'),
+    localStorageDir: text('local_storage_dir'),
+    attestationRaw: text('attestation_raw'),
+    attestationCreatedAt: int('attestation_created_at'),
+    contentHash: text('content_hash'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+    publisher: text('publisher'),
+});
+
+const appState = sqliteTable('appState', {
+    key: text('key').unique(),
+    value: text('value'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+const modelUids = sqliteTable('model_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    modelId: int('model_id')
+        .notNull()
+        .unique()
+        .references(() => models$1.id),
+});
+const modelRelations = relations(modelUids, ({ one }) => ({
+    model: one(models$1),
+}));
+
+const propertyUids = sqliteTable('property_uids', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    uid: text('uid').notNull(),
+    propertyId: int('property_id')
+        .notNull()
+        .unique()
+        .references(() => properties.id),
+});
+const propertyUidRelations = relations(propertyUids, ({ one }) => ({
+    property: one(properties),
+}));
+
+const config = sqliteTable('config', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    key: text('key').notNull(),
+    text: text('text'),
+    json: text('json'),
+    blob: blob('blob'),
+});
+
+const schemas = sqliteTable('schemas', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(),
+    version: integer('version').notNull(),
+    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
+    schemaData: text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
+    isDraft: integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
+    isEdited: integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+}, (table) => {
+    return {
+        uniqueSchemaFileId: unique('unique_schema_schema_file_id').on(table.schemaFileId),
+    };
+});
+
+var SchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    schemas: schemas
+});
+
+const modelSchemas = sqliteTable('model_schemas', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    modelId: integer('model_id').references(() => models$1.id),
+    schemaId: integer('schema_id').references(() => schemas.id),
+});
+
+var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    modelSchemas: modelSchemas
+});
+
+const publishProcesses = sqliteTable('publish_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: text('seed_local_id').notNull(),
+    modelName: text('model_name').notNull(),
+    schemaId: text('schema_id'),
+    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
+    startedAt: int('started_at').notNull(),
+    completedAt: int('completed_at'),
+    errorMessage: text('error_message'),
+    errorStep: text('error_step'),
+    errorDetails: text('error_details'),
+    persistedSnapshot: text('persisted_snapshot').notNull(),
+    seedId: text('seed_id'),
+    existingSeedUid: text('existing_seed_uid'),
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+const uploadProcesses = sqliteTable('upload_processes', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    reimbursementConfirmed: int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
+    reimbursementTransactionId: text('reimbursement_transaction_id'),
+    transactionKeys: text('transaction_keys'),
+    persistedSnapshot: text('persisted_snapshot').notNull(), // JSON string
+    createdAt: int('created_at'),
+    updatedAt: int('updated_at'),
+});
+
+/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
+const arweaveL1FinalizeJobs = sqliteTable('arweave_l1_finalize_jobs', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: text('seed_local_id').notNull(),
+    dataItemId: text('data_item_id').notNull(),
+    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
+    l1TransactionId: text('l1_transaction_id'),
+    bundleId: text('bundle_id'),
+    versionLocalId: text('version_local_id'),
+    itemPropertyName: text('item_property_name'),
+    /** `pending_l1` | `confirmed` | `failed` */
+    phase: text('phase').notNull(),
+    statusJson: text('status_json'),
+    errorMessage: text('error_message'),
+    createdAt: int('created_at').notNull(),
+    updatedAt: int('updated_at').notNull(),
+}, (table) => ({
+    dataItemIdUnique: uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
+}));
+
+/**
+ * Links Image seeds materialized from Html `data:image/*` URIs to the parent Item seed for co-publish.
+ * Rows are removed after a successful publish (see clearHtmlEmbeddedImageCoPublishRows).
+ */
+const htmlEmbeddedImageCoPublish = sqliteTable('html_embedded_image_co_publish', {
+    id: int('id').primaryKey({ autoIncrement: true }),
+    parentSeedLocalId: text('parent_seed_local_id').notNull(),
+    htmlSeedLocalId: text('html_seed_local_id').notNull(),
+    imageSeedLocalId: text('image_seed_local_id').notNull(),
+    /** Stable dedup key (e.g. sha256 of data URI or normalized URI string). */
+    stableKey: text('stable_key').notNull(),
+    createdAt: int('created_at').notNull(),
+}, (t) => [
+    uniqueIndex('html_embed_co_pub_parent_html_stable').on(t.parentSeedLocalId, t.htmlSeedLocalId, t.stableKey),
+]);
+
+const seedUidToStorageTransactionId = new Map();
+const getStorageTransactionIdForSeedUid = async (seedUid) => {
+    if (seedUidToStorageTransactionId.has(seedUid)) {
+        return seedUidToStorageTransactionId.get(seedUid);
+    }
+    const appDb = BaseDb.getAppDb();
+    const results = (await appDb
+        .select({
+        storageTransactionId: metadata$1.propertyValue,
+    })
+        .from(metadata$1)
+        .where(and(eq(metadata$1.seedUid, seedUid), eq(metadata$1.propertyName, 'storageTransactionId'))));
+    if (!results || results.length === 0) {
+        return;
+    }
+    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
+    return results[0].storageTransactionId;
+};
+
+const logger$v = debug('seedSdk:helpers:mediaRef');
+/** Typical Arweave transaction id: 43 URL-safe base64 characters. */
+const ARWEAVE_TX_ID = /^[a-zA-Z0-9_-]{43}$/;
+function trimOrEmpty(raw) {
+    if (raw == null)
+        return '';
+    return typeof raw === 'string' ? raw.trim() : String(raw).trim();
+}
+function coalesceStringField(item, key) {
+    const v = item[key];
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v.trim();
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return '';
+}
+/**
+ * Try JSON relation payloads and plain relation id strings.
+ */
+function unwrapRelationString(raw) {
+    const t = raw.trim();
+    if (!t)
+        return t;
+    try {
+        const parsed = JSON.parse(t);
+        const fromObj = normalizeRelationPropertyValue(parsed);
+        if (fromObj)
+            return fromObj;
+    }
+    catch {
+        // not JSON
+    }
+    return t;
+}
+/**
+ * Pure, sync classification of a media-related string from feeds or XML.
+ */
+function classifyMediaRef(raw, options) {
+    const s = trimOrEmpty(raw);
+    if (!s) {
+        return { kind: 'empty' };
+    }
+    const treatAs = options?.treatAs;
+    if (treatAs === 'url') {
+        return { kind: 'url', href: s };
+    }
+    if (treatAs === 'arweaveTx') {
+        return { kind: 'arweaveTxId', txId: s };
+    }
+    if (treatAs === 'seedUid') {
+        if (s.startsWith('0x') && s.length === 66) {
+            return { kind: 'seedUid', uid: s };
+        }
+        return { kind: 'unknown', raw: s };
+    }
+    if (s.startsWith('http://') || s.startsWith('https://') || s.startsWith('blob:') || s.startsWith('data:')) {
+        return { kind: 'url', href: s };
+    }
+    const unwrapped = unwrapRelationString(s);
+    const ids = resolveSeedIdsFromRefString(unwrapped);
+    if (ids.seedUid) {
+        return { kind: 'seedUid', uid: ids.seedUid };
+    }
+    if (ids.seedLocalId) {
+        return { kind: 'seedLocalId', localId: ids.seedLocalId };
+    }
+    if (unwrapped.startsWith('0x') && unwrapped.length === 66) {
+        return { kind: 'seedUid', uid: unwrapped };
+    }
+    if (ARWEAVE_TX_ID.test(unwrapped) && !unwrapped.startsWith('0x')) {
+        return { kind: 'arweaveTxId', txId: unwrapped };
+    }
+    return { kind: 'unknown', raw: s };
+}
+/**
+ * Same as convertTxIdToImage but local to this module to avoid circular imports with helpers/index.
+ */
+async function tryLocalBlobUrlFromTxId(txId) {
+    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
+    const fileExists = await BaseFileManager.pathExists(imageFilePath);
+    if (!fileExists) {
+        logger$v(`[tryLocalBlobUrlFromTxId] ${imageFilePath} does not exist`);
+        return undefined;
+    }
+    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
+    let arrayBuffer;
+    if (buffer instanceof Blob) {
+        arrayBuffer = await buffer.arrayBuffer();
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        arrayBuffer = buffer;
+    }
+    else {
+        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        if (sliced instanceof SharedArrayBuffer) {
+            const uint8Array = new Uint8Array(sliced);
+            arrayBuffer = uint8Array.buffer.slice(0);
+        }
+        else {
+            arrayBuffer = sliced;
+        }
+    }
+    const uint = new Uint8Array(arrayBuffer);
+    const imageBlob = new Blob([uint]);
+    return URL.createObjectURL(imageBlob);
+}
+async function resolveTxId(txId) {
+    const local = await tryLocalBlobUrlFromTxId(txId);
+    if (local) {
+        return { status: 'ready', href: local, source: 'localBlob' };
+    }
+    return {
+        status: 'ready',
+        href: BaseArweaveClient.getRawUrl(txId),
+        source: 'gateway',
+    };
+}
+/**
+ * Resolve a classified media reference to a display URL (https/blob/data), using local files when present.
+ */
+async function resolveMediaRef(raw, options) {
+    const classification = classifyMediaRef(raw, options);
+    switch (classification.kind) {
+        case 'empty':
+            return { status: 'empty' };
+        case 'url':
+            return {
+                status: 'ready',
+                href: classification.href,
+                source: 'direct',
+            };
+        case 'seedLocalId':
+            return {
+                status: 'unresolved',
+                reason: 'seed_local_id_not_portable',
+                classification,
+            };
+        case 'unknown':
+            return {
+                status: 'unresolved',
+                reason: 'unknown_ref',
+                classification,
+            };
+        case 'arweaveTxId':
+            return resolveTxId(classification.txId);
+        case 'seedUid': {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb) {
+                return {
+                    status: 'unresolved',
+                    reason: 'seed_uid_requires_app_db',
+                    classification,
+                };
+            }
+            const storageTransactionId = await getStorageTransactionIdForSeedUid(classification.uid);
+            if (!storageTransactionId) {
+                return {
+                    status: 'unresolved',
+                    reason: 'seed_uid_no_storage_transaction',
+                    classification,
+                };
+            }
+            return resolveTxId(storageTransactionId);
+        }
+        default:
+            return {
+                status: 'unresolved',
+                reason: 'unknown_ref',
+                classification,
+            };
+    }
+}
+/**
+ * Read a string field from a parsed item, trying camelCase and snake_case keys.
+ */
+function getFeedItemStringField(item, key) {
+    const direct = coalesceStringField(item, key);
+    if (direct)
+        return direct;
+    const snake = key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`);
+    if (snake !== key) {
+        const alt = coalesceStringField(item, snake);
+        if (alt)
+            return alt;
+    }
+    const parts = key.split('_');
+    if (parts.length > 1) {
+        const camel = parts[0] + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+        const alt2 = coalesceStringField(item, camel);
+        if (alt2)
+            return alt2;
+    }
+    return '';
+}
+/**
+ * Apply a field manifest to a plain feed item: classify media/file fields; pass through html/text.
+ */
+function normalizeFeedItemFields(item, manifest) {
+    const out = {};
+    for (const [fieldKey, descriptor] of Object.entries(manifest)) {
+        const raw = getFeedItemStringField(item, fieldKey);
+        if (!raw) {
+            out[fieldKey] = undefined;
+            continue;
+        }
+        if (descriptor.role === 'html') {
+            out[fieldKey] = { role: 'html', raw };
+            continue;
+        }
+        if (descriptor.role === 'text') {
+            out[fieldKey] = { role: 'text', raw };
+            continue;
         }
+        const classification = classifyMediaRef(raw, { treatAs: descriptor.treatAs });
+        out[fieldKey] = {
+            role: descriptor.role,
+            raw,
+            classification,
+        };
     }
-    return undefined;
+    return out;
 }
-/** 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 the value is not a real EAS attestation UID stored in SQLite
+ * (missing, empty, legacy 'NULL' sentinel, or zero bytes32).
+ */
+function isPlaceholderUid(value) {
+    if (value == null || value === '')
+        return true;
+    if (value === 'NULL')
+        return true;
+    const v = value.trim();
+    if (v === '')
+        return true;
+    if (v.toLowerCase() === ZERO_BYTES32.toLowerCase())
+        return true;
+    return false;
+}
+/**
+ * Strict EAS attestation UID: 0x-prefixed 32-byte hex (case-insensitive 0x / hex body).
+ * Excludes placeholders and ZERO_BYTES32.
+ */
+function isValidEasAttestationUid(value) {
+    if (isPlaceholderUid(value))
+        return false;
+    const v = String(value).trim();
+    if (!/^0x/i.test(v))
+        return false;
+    const hex = v.slice(2);
+    if (hex.length !== 64)
+        return false;
+    return /^[0-9a-fA-F]{64}$/.test(hex);
+}
+/** Normalize bytes32 hex strings for case-insensitive comparison (schema UIDs, etc.). */
+function normalizeBytes32Hex(value) {
+    if (value == null || value === '')
+        return '';
+    const raw = String(value).trim();
+    const body = raw.startsWith('0x') || raw.startsWith('0X') ? raw.slice(2) : raw;
+    const hex = body.replace(/[^0-9a-fA-F]/g, '0').padStart(64, '0').slice(-64);
+    return ('0x' + hex).toLowerCase();
 }
 
 function pickLatestPropertyAttestationsByRefAndSchema(attestations) {
@@ -1343,6 +1862,7 @@ var index = /*#__PURE__*/Object.freeze({
     BaseFileManager: BaseFileManager,
     BaseQueryClient: BaseQueryClient,
     capitalizeFirstLetter: capitalizeFirstLetter,
+    classifyMediaRef: classifyMediaRef,
     convertTxIdToImage: convertTxIdToImage,
     generateId: generateId,
     getAlternatePropertyNameForInstanceLookup: getAlternatePropertyNameForInstanceLookup,
@@ -1351,6 +1871,7 @@ var index = /*#__PURE__*/Object.freeze({
     getCorrectId: getCorrectId,
     getDataTypeFromString: getDataTypeFromString,
     getExecutionTime: getExecutionTime,
+    getFeedItemStringField: getFeedItemStringField,
     getGetAdditionalSyncAddresses: getGetAdditionalSyncAddresses,
     getGetPublisherForNewSeeds: getGetPublisherForNewSeeds,
     getMetadataPropertyNamesForQuery: getMetadataPropertyNamesForQuery,
@@ -1364,13 +1885,18 @@ var index = /*#__PURE__*/Object.freeze({
     identifyString: identifyString,
     isArweaveL1AnchoringComplete: isArweaveL1AnchoringComplete,
     isBinary: isBinary,
+    isPlaceholderUid: isPlaceholderUid,
+    isValidEasAttestationUid: isValidEasAttestationUid,
     listRelationStoragePropertyName: listRelationStoragePropertyName,
     needsMetadataIdSuffix: needsMetadataIdSuffix,
+    normalizeBytes32Hex: normalizeBytes32Hex,
+    normalizeFeedItemFields: normalizeFeedItemFields,
     normalizeRelationPropertyValue: normalizeRelationPropertyValue,
     normalizeUploadApiBaseUrl: normalizeUploadApiBaseUrl,
     parseEasRelationPropertyName: parseEasRelationPropertyName,
     pickLatestPropertyAttestationsByRefAndSchema: pickLatestPropertyAttestationsByRefAndSchema,
     queryArweaveGatewayTransaction: queryArweaveGatewayTransaction,
+    resolveMediaRef: resolveMediaRef,
     resolveMetadataRecord: resolveMetadataRecord,
     resolveSeedIdsFromRefString: resolveSeedIdsFromRefString,
     resolveStorageNameToSchemaName: resolveStorageNameToSchemaName,
@@ -1396,7 +1922,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-Csj84uQv.js');
+        const mod = await import('./ModelProperty-DWtv9fQr.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1580,7 +2106,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const _mod_0 = await import('./Schema-QjwZN91G.js');
+            const _mod_0 = await import('./Schema-CqqcEexA.js');
             const _ns_0 = _mod_0.b;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -1826,7 +2352,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_1 = await import('./Schema-QjwZN91G.js');
+            const _mod_1 = await import('./Schema-CqqcEexA.js');
             const _ns_1 = _mod_1.b;
             const schemaMod = _ns_1;
             const { Schema } = schemaMod;
@@ -1872,10 +2398,10 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-Cwkeb4fG.js');
+            const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_2 = await import('./Schema-QjwZN91G.js');
+            const _mod_2 = await import('./Schema-CqqcEexA.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -1987,7 +2513,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$r(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-Csj84uQv.js');
+        const mod = await import('./ModelProperty-DWtv9fQr.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$r('ModelProperty not available from dynamic import');
@@ -2091,7 +2617,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$q(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-Cwkeb4fG.js');
+                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -2109,7 +2635,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$q(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_3 = await import('./Schema-QjwZN91G.js');
+                            const _mod_3 = await import('./Schema-CqqcEexA.js');
                             const _ns_3 = _mod_3.b;
                             const schemaMod = _ns_3;
                             const { Schema } = schemaMod;
@@ -2147,7 +2673,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-Cwkeb4fG.js');
+                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -2162,7 +2688,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_4 = await import('./Schema-QjwZN91G.js');
+                            const _mod_4 = await import('./Schema-CqqcEexA.js');
                             const _ns_4 = _mod_4.b;
                             const schemaMod = _ns_4;
                             const { Schema } = schemaMod;
@@ -2193,7 +2719,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-Cwkeb4fG.js');
+                const validationServiceMod = await import('./SchemaValidationService-Cb-b4kpD.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -2222,180 +2748,6 @@ const validateEntity = fromPromise(async ({ input }) => {
     // @ts-ignore - XState v5 type inference bug: fromPromise incorrectly expects output type to match input type
 });
 
-const seeds = sqliteTable('seeds', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    schemaUid: text('schema_uid'),
-    type: text('type'),
-    publisher: text('publisher'),
-    attestationRaw: text('attestation_raw'),
-    attestationCreatedAt: int('attestation_created_at'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-    _markedForDeletion: int('_marked_for_deletion'),
-    revokedAt: int('revoked_at'),
-});
-
-const versions = sqliteTable('versions', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    seedLocalId: text('seed_local_id'),
-    seedUid: text('seed_uid'),
-    seedType: text('seed_type'),
-    note: text('note'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-    attestationCreatedAt: int('attestation_created_at'),
-    attestationRaw: text('attestation_raw'),
-    publisher: text('publisher'),
-});
-
-const metadata$1 = sqliteTable('metadata', {
-    localId: text('local_id').unique(),
-    uid: text('uid'),
-    propertyId: integer('property_id').references(() => properties.id),
-    propertyName: text('property_name'),
-    propertyValue: text('property_value'),
-    schemaUid: text('schema_uid'),
-    modelType: text('model_type'),
-    seedLocalId: text('seed_local_id'),
-    seedUid: text('seed_uid'),
-    versionLocalId: text('version_local_id'),
-    versionUid: text('version_uid'),
-    easDataType: text('eas_data_type'),
-    refValueType: text('ref_value_type'),
-    refModelUid: text('ref_schema_uid'),
-    refSeedType: text('ref_seed_type'),
-    refResolvedValue: text('ref_resolved_value'),
-    refResolvedDisplayValue: text('ref_resolved_display_value'),
-    localStorageDir: text('local_storage_dir'),
-    attestationRaw: text('attestation_raw'),
-    attestationCreatedAt: int('attestation_created_at'),
-    contentHash: text('content_hash'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-    publisher: text('publisher'),
-});
-
-const appState = sqliteTable('appState', {
-    key: text('key').unique(),
-    value: text('value'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-const modelUids = sqliteTable('model_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    modelId: int('model_id')
-        .notNull()
-        .unique()
-        .references(() => models$1.id),
-});
-const modelRelations = relations(modelUids, ({ one }) => ({
-    model: one(models$1),
-}));
-
-const propertyUids = sqliteTable('property_uids', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    uid: text('uid').notNull(),
-    propertyId: int('property_id')
-        .notNull()
-        .unique()
-        .references(() => properties.id),
-});
-const propertyUidRelations = relations(propertyUids, ({ one }) => ({
-    property: one(properties),
-}));
-
-const config = sqliteTable('config', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    key: text('key').notNull(),
-    text: text('text'),
-    json: text('json'),
-    blob: blob('blob'),
-});
-
-const schemas = sqliteTable('schemas', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    name: text('name').notNull(),
-    version: integer('version').notNull(),
-    schemaFileId: text('schema_file_id'), // ID from JSON file for change tracking - must be unique
-    schemaData: text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
-    isDraft: integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
-    isEdited: integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-}, (table) => {
-    return {
-        uniqueSchemaFileId: unique('unique_schema_schema_file_id').on(table.schemaFileId),
-    };
-});
-
-var SchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    schemas: schemas
-});
-
-const modelSchemas = sqliteTable('model_schemas', {
-    id: integer('id').primaryKey({ autoIncrement: true }),
-    modelId: integer('model_id').references(() => models$1.id),
-    schemaId: integer('schema_id').references(() => schemas.id),
-});
-
-var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    modelSchemas: modelSchemas
-});
-
-const publishProcesses = sqliteTable('publish_processes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: text('seed_local_id').notNull(),
-    modelName: text('model_name').notNull(),
-    schemaId: text('schema_id'),
-    status: text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
-    startedAt: int('started_at').notNull(),
-    completedAt: int('completed_at'),
-    errorMessage: text('error_message'),
-    errorStep: text('error_step'),
-    errorDetails: text('error_details'),
-    persistedSnapshot: text('persisted_snapshot').notNull(),
-    seedId: text('seed_id'),
-    existingSeedUid: text('existing_seed_uid'),
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-const uploadProcesses = sqliteTable('upload_processes', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    reimbursementConfirmed: int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
-    reimbursementTransactionId: text('reimbursement_transaction_id'),
-    transactionKeys: text('transaction_keys'),
-    persistedSnapshot: text('persisted_snapshot').notNull(), // JSON string
-    createdAt: int('created_at'),
-    updatedAt: int('updated_at'),
-});
-
-/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
-const arweaveL1FinalizeJobs = sqliteTable('arweave_l1_finalize_jobs', {
-    id: int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: text('seed_local_id').notNull(),
-    dataItemId: text('data_item_id').notNull(),
-    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
-    l1TransactionId: text('l1_transaction_id'),
-    bundleId: text('bundle_id'),
-    versionLocalId: text('version_local_id'),
-    itemPropertyName: text('item_property_name'),
-    /** `pending_l1` | `confirmed` | `failed` */
-    phase: text('phase').notNull(),
-    statusJson: text('status_json'),
-    errorMessage: text('error_message'),
-    createdAt: int('created_at').notNull(),
-    updatedAt: int('updated_at').notNull(),
-}, (table) => ({
-    dataItemIdUnique: uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
-}));
-
 const logger$p = debug('seedSdk:helpers:db');
 /**
  * Resolve property_id from model name/type and property name.
@@ -4319,7 +4671,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-Csj84uQv.js');
+                    const mod = await import('./ModelProperty-DWtv9fQr.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4699,7 +5051,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-Csj84uQv.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-DWtv9fQr.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5771,9 +6123,9 @@ const createVersion = async ({ seedLocalId, seedUid, seedType, uid, }) => {
         localId: newVersionLocalId,
         createdAt: Date.now(),
         seedLocalId,
-        seedUid: seedUid ?? 'NULL',
+        seedUid: seedUid ?? null,
         seedType,
-        uid: uid || 'NULL',
+        uid: uid ?? null,
         ...(publisher != null && publisher !== '' && { publisher }),
     });
     return newVersionLocalId;
@@ -5788,12 +6140,12 @@ const hydrateNewItem = fromCallback(({ sendBack, input: { context } }) => {
         }
         newSeedLocalId = await createSeed({
             type: modelName.toLowerCase(),
-            seedUid: seedUid ?? 'NULL',
+            ...(seedUid && seedUid !== 'NULL' ? { seedUid } : {}),
         });
         await createVersion({
             seedLocalId: newSeedLocalId,
             seedType: modelName.toLowerCase(),
-            uid: versionUid ?? 'NULL',
+            ...(versionUid && versionUid !== 'NULL' ? { uid: versionUid } : {}),
         });
     };
     _hydrateNewItem().then(() => {
@@ -5925,28 +6277,145 @@ const reload = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
+/**
+ * Per-seed aggregates (all versions) plus the latest version row by
+ * (created_at DESC, local_id DESC) via max(created_at) then max(local_id) tie-break.
+ *
+ * For `publishedVersionUid` / `publishedVersionLocalId` on list rows, see `getItemsData`
+ * (batched resolution aligned with `getLatestPublishedVersionRow`).
+ */
 const getVersionData$1 = () => {
     const appDb = BaseDb.getAppDb();
+    const versionStats = appDb.$with('version_stats').as(appDb
+        .select({
+        seedLocalId: versions.seedLocalId,
+        versionsCount: count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
+        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+        maxCreatedAt: max(versions.createdAt).as('maxCreatedAt'),
+    })
+        .from(versions)
+        .groupBy(versions.seedLocalId));
+    const latestVersionIds = appDb.$with('latest_version_ids').as(appDb
+        .with(versionStats)
+        .select({
+        seedLocalId: versions.seedLocalId,
+        latestVersionLocalId: max(versions.localId).as('latestVersionLocalId'),
+    })
+        .from(versions)
+        .innerJoin(versionStats, and(eq(versions.seedLocalId, versionStats.seedLocalId), eq(versions.createdAt, versionStats.maxCreatedAt)))
+        .groupBy(versions.seedLocalId));
     return appDb.$with('versionData').as(appDb
+        .with(versionStats, latestVersionIds)
+        .select({
+        seedLocalId: versionStats.seedLocalId,
+        seedUid: versions.seedUid,
+        latestVersionUid: versions.uid,
+        latestVersionLocalId: latestVersionIds.latestVersionLocalId,
+        versionsCount: versionStats.versionsCount,
+        lastVersionPublishedAt: versionStats.lastVersionPublishedAt,
+        lastLocalUpdateAt: versionStats.lastLocalUpdateAt,
+    })
+        .from(versionStats)
+        .innerJoin(latestVersionIds, eq(versionStats.seedLocalId, latestVersionIds.seedLocalId))
+        .innerJoin(versions, and(eq(versions.seedLocalId, latestVersionIds.seedLocalId), eq(versions.localId, latestVersionIds.latestVersionLocalId))));
+};
+
+var versionData = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getVersionData: getVersionData$1
+});
+
+const getMetadataLatest = ({ seedLocalId, seedUid }) => {
+    const appDb = BaseDb.getAppDb();
+    const whereClauses = [];
+    if (seedLocalId && seedUid) {
+        const orClause = or(eq(metadata$1.seedLocalId, seedLocalId), eq(metadata$1.seedUid, seedUid));
+        if (orClause)
+            whereClauses.push(orClause);
+    }
+    else if (seedLocalId) {
+        whereClauses.push(eq(metadata$1.seedLocalId, seedLocalId));
+    }
+    else if (seedUid) {
+        whereClauses.push(eq(metadata$1.seedUid, seedUid));
+    }
+    const metadataColumns = getTableColumns(metadata$1);
+    return appDb.$with('metadataLatest').as(appDb
         .select({
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-        latestVersionUid: versions.uid,
-        latestVersionLocalId: versions.localId,
-        versionsCount: count(versions.localId).as('versionsCount'),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+        ...metadataColumns,
+        rowNum: sql.raw(`
+           ROW_NUMBER() OVER (
+               PARTITION BY property_name 
+               ORDER BY COALESCE(attestation_created_at, created_at) DESC
+           )
+          `).as('rowNum')
     })
-        .from(versions)
-        .groupBy(versions.seedLocalId));
+        .from(metadata$1)
+        .where(and(...whereClauses)));
 };
 
-var versionData = /*#__PURE__*/Object.freeze({
+var metadataLatest = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getVersionData: getVersionData$1
+    getMetadataLatest: getMetadataLatest
 });
 
 const logger$l = debug('seedSdk:item:actors:loadOrCreateItem');
+/**
+ * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
+ */
+function normalizeMetadataRowToInstanceKey(metaRow, propertySchemas) {
+    let propertyName = metaRow.propertyName;
+    if (!propertyName)
+        return undefined;
+    const listSchemaKey = resolveStorageNameToSchemaName(propertySchemas, propertyName);
+    if (listSchemaKey) {
+        propertyName = listSchemaKey;
+    }
+    else {
+        const baseName = toSchemaPropertyName(propertyName);
+        const refSeedType = metaRow.refSeedType;
+        const isRefTypeFromMeta = refSeedType === 'file' ||
+            refSeedType === 'image' ||
+            refSeedType === 'relation' ||
+            refSeedType === 'html';
+        if (baseName && (propertySchemas[baseName] || isRefTypeFromMeta)) {
+            propertyName = baseName;
+        }
+    }
+    return propertyName;
+}
+function metadataValueStrength(row) {
+    const v = row?.propertyValue;
+    if (v == null || v === '')
+        return 0;
+    return String(v).trim().length;
+}
+/** When storage + schema names map to the same key, prefer non-empty, then richer payload, then newer row. */
+function pickBetterMetadataRowForSameInstance(a, b) {
+    const sa = metadataValueStrength(a);
+    const sb = metadataValueStrength(b);
+    if (sa > 0 && sb === 0)
+        return a;
+    if (sb > 0 && sa === 0)
+        return b;
+    if (sa !== sb)
+        return sa > sb ? a : b;
+    const ta = a.attestationCreatedAt ?? a.createdAt ?? 0;
+    const tb = b.attestationCreatedAt ?? b.createdAt ?? 0;
+    return ta >= tb ? a : b;
+}
+function dedupeMetadataRowsByInstanceKey(metadataRows, propertySchemas) {
+    const byKey = new Map();
+    for (const metaRow of metadataRows) {
+        const key = normalizeMetadataRowToInstanceKey(metaRow, propertySchemas);
+        if (!key)
+            continue;
+        const existing = byKey.get(key);
+        byKey.set(key, existing ? pickBetterMetadataRowForSameInstance(existing, metaRow) : metaRow);
+    }
+    return Array.from(byKey.values());
+}
 /**
  * Create ItemProperty instances for all metadata records plus placeholder instances
  * for model schema properties that have no metadata. Ensures items (e.g. Image) have
@@ -5982,7 +6451,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const _mod_5 = await import('./Schema-QjwZN91G.js');
+                    const _mod_5 = await import('./Schema-CqqcEexA.js');
                     const _ns_5 = _mod_5.b;
                     const { Schema } = _ns_5;
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
@@ -6033,13 +6502,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await import('./index-DvUyNZc9.js');
+                const schemaMod = await import('./index-Cqf_DxkJ.js');
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
                         html: { dataType: ModelPropertyDataTypes.Html },
                         summary: { dataType: ModelPropertyDataTypes.Text },
                         title: { dataType: ModelPropertyDataTypes.Text },
+                        authors: { dataType: ModelPropertyDataTypes.List, ref: 'Identity' },
                     },
                 };
                 if (KNOWN_MODEL_FALLBACKS[modelName]) {
@@ -6048,17 +6518,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
         }
-        // Build map of metadata by propertyName for lookup
-        const metadataByProperty = new Map();
-        for (const metaRow of metadataRows) {
-            if (metaRow.propertyName) {
-                metadataByProperty.set(metaRow.propertyName, metaRow);
-            }
-        }
+        // 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.
+        const dedupedMetadataRows = dedupeMetadataRowsByInstanceKey(metadataRows, propertySchemas);
         // Create instances for all metadata records
         // For File/Image/Relation, metadata is stored with Id suffix (e.g. "textId") but schema defines base name ("text").
         // Normalize to schema name so we don't create duplicate properties (text + textId).
-        for (const metaRow of metadataRows) {
+        for (const metaRow of dedupedMetadataRows) {
             try {
                 let propertyName = metaRow.propertyName;
                 if (!propertyName) {
@@ -6082,7 +6549,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-DvUyNZc9.js');
+                    const schemaMod = await import('./index-Cqf_DxkJ.js');
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6272,18 +6739,26 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             });
             return;
         }
-        // Step 3: Query metadata table to find all metadata records that reference that version
+        // Step 3: Latest metadata row per property_name for this seed (matches loadOrCreateProperty /
+        // getItemProperties). Strict version_local_id = latest would drop properties whose rows lag version bumps.
+        const metadataLatest = getMetadataLatest({
+            seedLocalId: resolvedSeedLocalId,
+            seedUid: resolvedSeedUid,
+        });
         const metadataRecords = await db
+            .with(metadataLatest)
             .select()
-            .from(metadata$1)
-            .where(and(eq(metadata$1.seedLocalId, resolvedSeedLocalId), eq(metadata$1.versionLocalId, latestVersionLocalId)));
-        logger$l(`Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
+            .from(metadataLatest)
+            .where(eq(metadataLatest.rowNum, 1));
+        logger$l(`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);
         // Step 4b: Wait for all property machines to reach idle so HTML/File content is loaded before Item is ready.
         // Without this, post.html returns seed ID on first render because loadOrCreateProperty hasn't finished.
-        await Promise.all(Array.from(propertyInstances.values()).map((prop) => waitForEntityIdle(prop, { timeout: 5000, throwOnError: false })));
+        // Publish/attestation can keep properties in `saving` for many seconds; 5s caused timeouts during EAS work.
+        const propertyIdleTimeoutMs = 120000;
+        await Promise.all(Array.from(propertyInstances.values()).map((prop) => waitForEntityIdle(prop, { timeout: propertyIdleTimeoutMs, throwOnError: false })));
         // Step 5: Return loaded item data with property instances
         sendBack({
             type: 'loadOrCreateItemSuccess',
@@ -6300,6 +6775,7 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
                 createdAt: seedRecord.createdAt || Date.now(),
                 publisher: seedRecord.publisher ?? undefined,
                 revokedAt: seedRecord.revokedAt ?? undefined,
+                // One id per property_name (latest row), not the full set of rows for latest version
                 _metadataIds: metadataRecords.map((r) => r.localId || r.uid).filter(Boolean),
                 propertyInstances,
             },
@@ -6330,9 +6806,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-DTE4SEWk.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-DS2dQ4Ho.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-CMhy9jfz.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-DpYwi-rd.js');
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6624,40 +7100,6 @@ const itemMachineSingle = setup({
     },
 });
 
-const getMetadataLatest = ({ seedLocalId, seedUid }) => {
-    const appDb = BaseDb.getAppDb();
-    const whereClauses = [];
-    if (seedLocalId && seedUid) {
-        const orClause = or(eq(metadata$1.seedLocalId, seedLocalId), eq(metadata$1.seedUid, seedUid));
-        if (orClause)
-            whereClauses.push(orClause);
-    }
-    else if (seedLocalId) {
-        whereClauses.push(eq(metadata$1.seedLocalId, seedLocalId));
-    }
-    else if (seedUid) {
-        whereClauses.push(eq(metadata$1.seedUid, seedUid));
-    }
-    const metadataColumns = getTableColumns(metadata$1);
-    return appDb.$with('metadataLatest').as(appDb
-        .select({
-        ...metadataColumns,
-        rowNum: sql.raw(`
-           ROW_NUMBER() OVER (
-               PARTITION BY property_name 
-               ORDER BY COALESCE(attestation_created_at, created_at) DESC
-           )
-          `).as('rowNum')
-    })
-        .from(metadata$1)
-        .where(and(...whereClauses)));
-};
-
-var metadataLatest = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getMetadataLatest: getMetadataLatest
-});
-
 const getItemProperties = async ({ seedLocalId, seedUid, edited, }) => {
     const appDb = BaseDb.getAppDb();
     const whereClauses = [isNotNull(metadata$1.propertyName)];
@@ -6712,6 +7154,35 @@ const getSeedData = async ({ seedLocalId, seedUid }) => {
     return rows[0];
 };
 
+/**
+ * Latest version row for the seed (by createdAt) whose uid is a real EAS attestation id.
+ * Skips legacy 'NULL' / ZERO_BYTES32 placeholders and non-bytes32 strings.
+ */
+async function getLatestPublishedVersionRow(seedLocalId) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !seedLocalId)
+        return null;
+    const vRows = await appDb
+        .select({
+        localId: versions.localId,
+        uid: versions.uid,
+        attestationCreatedAt: versions.attestationCreatedAt,
+    })
+        .from(versions)
+        .where(eq(versions.seedLocalId, seedLocalId))
+        .orderBy(desc(versions.createdAt));
+    for (const vr of vRows) {
+        if (vr.uid && isValidEasAttestationUid(vr.uid)) {
+            return {
+                uid: vr.uid,
+                localId: vr.localId ?? null,
+                attestationCreatedAt: vr.attestationCreatedAt ?? null,
+            };
+        }
+    }
+    return null;
+}
+
 const logger$j = debug('seedSdk:db:read:getItemData');
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
@@ -6780,21 +7251,51 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         lastVersionPublishedAt: null,
         latestVersionUid: null,
         latestVersionLocalId: null,
+        publishedVersionUid: null,
+        publishedVersionLocalId: null,
+        lastLocalUpdateAt: null,
     };
     try {
-        const versionRows = await appDb
+        const allVersions = await appDb
             .select({
-            versionsCount: count(versions.localId).as('versionsCount'),
-            lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-            latestVersionUid: max(versions.uid).as('latestVersionUid'),
-            latestVersionLocalId: max(versions.localId).as('latestVersionLocalId'),
+            localId: versions.localId,
+            uid: versions.uid,
+            createdAt: versions.createdAt,
+            attestationCreatedAt: versions.attestationCreatedAt,
         })
             .from(versions)
-            .where(eq(versions.seedLocalId, resolvedSeedLocalId))
-            .groupBy(versions.seedLocalId)
-            .limit(1);
-        if (versionRows && versionRows.length > 0) {
-            versionRow = versionRows[0];
+            .where(eq(versions.seedLocalId, resolvedSeedLocalId));
+        if (allVersions.length > 0) {
+            const sorted = [...allVersions].sort((a, b) => {
+                const ca = a.createdAt ?? 0;
+                const cb = b.createdAt ?? 0;
+                if (cb !== ca)
+                    return cb - ca;
+                return String(b.localId ?? '').localeCompare(String(a.localId ?? ''));
+            });
+            const latest = sorted[0];
+            let lastPub = null;
+            for (const v of allVersions) {
+                const t = v.attestationCreatedAt;
+                if (t != null && (lastPub == null || t > lastPub))
+                    lastPub = t;
+            }
+            let lastLocal = 0;
+            for (const v of allVersions) {
+                const t = v.createdAt ?? 0;
+                if (t > lastLocal)
+                    lastLocal = t;
+            }
+            const published = await getLatestPublishedVersionRow(resolvedSeedLocalId);
+            versionRow = {
+                versionsCount: allVersions.length,
+                lastVersionPublishedAt: lastPub,
+                latestVersionUid: latest.uid ?? null,
+                latestVersionLocalId: latest.localId ?? null,
+                publishedVersionUid: published?.uid ?? null,
+                publishedVersionLocalId: published?.localId ?? null,
+                lastLocalUpdateAt: lastLocal || null,
+            };
         }
     }
     catch (error) {
@@ -6826,11 +7327,65 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         return itemData;
 };
 
+/**
+ * One round-trip for list views: for each seed, the same row as {@link getLatestPublishedVersionRow}
+ * (newest `created_at` whose `uid` is a valid EAS attestation id).
+ */
+async function batchLatestPublishedVersionBySeedLocalIds(seedLocalIds) {
+    const out = new Map();
+    if (seedLocalIds.length === 0)
+        return out;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return out;
+    const rows = await appDb
+        .select({
+        seedLocalId: versions.seedLocalId,
+        localId: versions.localId,
+        uid: versions.uid,
+        createdAt: versions.createdAt,
+    })
+        .from(versions)
+        .where(inArray(versions.seedLocalId, seedLocalIds));
+    const bySeed = new Map();
+    for (const r of rows) {
+        const sid = r.seedLocalId;
+        if (!sid)
+            continue;
+        const list = bySeed.get(sid) ?? [];
+        list.push(r);
+        bySeed.set(sid, list);
+    }
+    for (const [sid, list] of bySeed) {
+        const sorted = [...list].sort((a, b) => {
+            const ca = a.createdAt ?? 0;
+            const cb = b.createdAt ?? 0;
+            if (cb !== ca)
+                return cb - ca;
+            return String(b.localId ?? '').localeCompare(String(a.localId ?? ''));
+        });
+        const hit = sorted.find((r) => r.uid && isValidEasAttestationUid(r.uid));
+        if (hit?.uid) {
+            out.set(sid, { uid: hit.uid, localId: hit.localId ?? null });
+        }
+    }
+    return out;
+}
+
+/**
+ * List item rows for list UIs. Only includes seeds that have at least one version.
+ *
+ * - `includeEas: false` (default): drafts only — `seeds.uid` is null, empty, legacy `'NULL'`, or zero-bytes32.
+ *   On-chain seeds (real EAS seed UID) require `includeEas: true`.
+ * - `latestVersionUid` / `latestVersionLocalId`: head version **row** by `created_at` (may be unattested).
+ * - `publishedVersionUid` / `publishedVersionLocalId`: filled in a second batched read (same rules as
+ *   `getLatestPublishedVersionRow`).
+ */
 const getItemsData = async ({ modelName, deleted, includeEas = false, addressFilter, }) => {
     const appDb = BaseDb.getAppDb();
     const conditions = [];
     if (!includeEas) {
-        conditions.push(or(isNull(seeds.uid), eq(seeds.uid, '')));
+        conditions.push(or(isNull(seeds.uid), eq(seeds.uid, ''), eq(seeds.uid, 'NULL'), eq(seeds.uid, ZERO_BYTES32)));
     }
     if (modelName) {
         conditions.push(eq(seeds.type, toSnakeCase$1(modelName)));
@@ -6879,10 +7434,20 @@ const getItemsData = async ({ modelName, deleted, includeEas = false, addressFil
         .from(seeds)
         .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
         .where(and(gt(versionData.versionsCount, 0), ...conditions))
-        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'));
     const itemsData = (await query);
-    return itemsData;
+    const seedIds = itemsData
+        .map((r) => r.seedLocalId)
+        .filter((id) => typeof id === 'string' && id !== '');
+    const publishedBySeed = await batchLatestPublishedVersionBySeedLocalIds(seedIds);
+    return itemsData.map((row) => {
+        const pub = row.seedLocalId ? publishedBySeed.get(row.seedLocalId) : undefined;
+        return {
+            ...row,
+            publishedVersionUid: pub?.uid,
+            publishedVersionLocalId: pub?.localId ?? undefined,
+        };
+    });
 };
 
 const resolveRemoteStorage = fromCallback(({ sendBack, input: { context } }) => {
@@ -7049,25 +7614,6 @@ const initialize = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const seedUidToStorageTransactionId = new Map();
-const getStorageTransactionIdForSeedUid = async (seedUid) => {
-    if (seedUidToStorageTransactionId.has(seedUid)) {
-        return seedUidToStorageTransactionId.get(seedUid);
-    }
-    const appDb = BaseDb.getAppDb();
-    const results = (await appDb
-        .select({
-        storageTransactionId: metadata$1.propertyValue,
-    })
-        .from(metadata$1)
-        .where(and(eq(metadata$1.seedUid, seedUid), eq(metadata$1.propertyName, 'storageTransactionId'))));
-    if (!results || results.length === 0) {
-        return;
-    }
-    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
-    return results[0].storageTransactionId;
-};
-
 const getRelationValueData = async (propertyValue) => {
     const appDb = BaseDb.getAppDb();
     const rows = (await appDb
@@ -7097,7 +7643,7 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DvUyNZc9.js');
+        const schemaMod = await import('./index-Cqf_DxkJ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -7473,7 +8019,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-DvUyNZc9.js');
+        const schemaMod = await import('./index-Cqf_DxkJ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -7778,7 +8324,7 @@ const loadOrCreateProperty = fromCallback(({ sendBack, input: { context } }) =>
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await import('./property-BNt7Dkmw.js');
+                            const { getPropertySchema } = await import('./property-C63Ddzap.js');
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8162,9 +8708,9 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DvUyNZc9.js');
+        const schemaMod = await import('./index-Cqf_DxkJ.js');
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await import('./SchemaValidationService-Cwkeb4fG.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-Cb-b4kpD.js');
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8362,7 +8908,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await import('./SchemaValidationService-Cwkeb4fG.js');
+        const { SchemaValidationService } = await import('./SchemaValidationService-Cb-b4kpD.js');
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, propertyRecordSchema.dataType, propertyRecordSchema.validation, propertyRecordSchema.refValueType);
         if (!validationResult.isValid && validationResult.errors.length > 0) {
@@ -8949,7 +9495,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-DvUyNZc9.js');
+        const schemaMod = await import('./index-Cqf_DxkJ.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9964,7 +10510,9 @@ class ItemProperty {
                     }
                 }
             }
-            if (!this._alias && propertyName.endsWith('Id')) {
+            if (!this._alias &&
+                propertyName.endsWith('Id') &&
+                !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(propertyName)) {
                 this._alias = propertyName.slice(0, -2);
             }
             else if (!this._alias && propertyName.endsWith('Ids')) {
@@ -9981,7 +10529,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-DvUyNZc9.js');
+            const schemaMod = await import('./index-Cqf_DxkJ.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -10139,7 +10687,7 @@ class ItemProperty {
                 const normalizedRefValueType = normalizeDataType(propertyRecordSchema?.refValueType);
                 const propertyNames = getMetadataPropertyNamesForQuery(propertyName, normalizedDataType, normalizedRefValueType);
                 const propertyNameVariant = propertyNames.length > 1 ? propertyNames[1] : undefined;
-                const _mod_6 = await import('./index-dDmXPEJC.js');
+                const _mod_6 = await import('./index-DdzhrbkF.js');
                 const _ns_6 = _mod_6.s;
                 const seedSchemaMod = _ns_6;
                 const { metadata } = seedSchemaMod;
@@ -10840,7 +11388,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await import('./ownership-C7GyMbsf.js');
+        const { assertItemOwned } = await import('./ownership-BK6suksO.js');
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -10933,7 +11481,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_7 = await import('./index-dDmXPEJC.js');
+                    const _mod_7 = await import('./index-DdzhrbkF.js');
                     const _ns_7 = _mod_7.s;
                     const seedSchemaMod = _ns_7;
                     const { metadata } = seedSchemaMod;
@@ -11079,7 +11627,7 @@ const deleteItem = async ({ seedLocalId, seedUid }) => {
  * Updates seedUid and optionally publisher. Publisher is immutable once set:
  * we never overwrite an existing publisher (set at creation or from attestation).
  */
-const updateSeedUid = async ({ seedLocalId, seedUid, publisher, }) => {
+const updateSeedUid = async ({ seedLocalId, seedUid, publisher, attestationCreatedAt, }) => {
     if (!seedLocalId || !seedUid) {
         return;
     }
@@ -11100,6 +11648,7 @@ const updateSeedUid = async ({ seedLocalId, seedUid, publisher, }) => {
         .set({
         uid: seedUid,
         ...(shouldSetPublisher && { publisher }),
+        ...(attestationCreatedAt != null && { attestationCreatedAt }),
         updatedAt: Date.now(),
     })
         .where(eq(seeds.localId, seedLocalId));
@@ -11180,7 +11729,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await import('./ownership-C7GyMbsf.js');
+            const { assertItemOwned } = await import('./ownership-BK6suksO.js');
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -11204,7 +11753,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await import('./ownership-C7GyMbsf.js');
+            const { assertItemOwned } = await import('./ownership-BK6suksO.js');
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11240,21 +11789,26 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-DTE4SEWk.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-DS2dQ4Ho.js');
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await import('./getPublishPayload-CMhy9jfz.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-DpYwi-rd.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
-        this.persistSeedUid = async (publisher) => {
+        this.persistSeedUid = async (publisher, attestationCreatedAtMs) => {
             const ctx = this._getSnapshotContext();
             const seedLocalId = ctx.seedLocalId;
             const seedUid = ctx.seedUid;
             if (seedLocalId && seedUid && typeof seedUid === 'string' && seedUid.length > 0) {
-                await updateSeedUid({ seedLocalId, seedUid, publisher });
+                await updateSeedUid({
+                    seedLocalId,
+                    seedUid,
+                    publisher,
+                    ...(attestationCreatedAtMs != null && { attestationCreatedAt: attestationCreatedAtMs }),
+                });
             }
         };
         const { modelName, seedUid, schemaUid, seedLocalId, latestVersionLocalId, latestVersionUid, modelInstance, publisher, } = initialValues;
@@ -11298,7 +11852,9 @@ class Item {
                     transformedKey = key.slice(0, -3); // Remove 'Ids'
                     transformedKey = pluralize(transformedKey);
                 }
-                if (!propertyInstance.alias && key.endsWith('Id')) {
+                if (!propertyInstance.alias &&
+                    key.endsWith('Id') &&
+                    !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(key)) {
                     transformedKey = key.slice(0, -2); // Remove 'Id'
                 }
                 propertiesObj[transformedKey] = propertyInstance;
@@ -11372,9 +11928,8 @@ class Item {
         const modelPropertyNames = this._getModelPropertyNames(schemaNameForModel);
         const schemaKeys = modelPropertyNames.length > 0 ? modelPropertyNames : Object.keys(propertySchemas);
         // Normalize Id-suffix keys from initialValues: metadata stores textId but schema defines text
-        const ID_SUFFIX_NO_NORMALIZE = new Set(['storageTransactionId']);
         const normalizedKeysFromInitial = keysFromInitial.map((key) => {
-            if (key.endsWith('Id') && !ID_SUFFIX_NO_NORMALIZE.has(key)) {
+            if (key.endsWith('Id') && !PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP.has(key)) {
                 const baseName = key.slice(0, -2);
                 if (schemaKeys.length > 0 && schemaKeys.includes(baseName))
                     return baseName;
@@ -11430,7 +11985,18 @@ class Item {
                 }
                 if (!waitForReady)
                     return instance;
-                await waitForEntityIdle(instance, { timeout: readyTimeout });
+                try {
+                    await waitForEntityIdle(instance, { timeout: readyTimeout });
+                }
+                catch (err) {
+                    try {
+                        instance.unload();
+                    }
+                    catch {
+                        /* best-effort cache cleanup */
+                    }
+                    throw err;
+                }
                 return instance;
             }
             if (!this.instanceCache.has(seedId)) {
@@ -11528,7 +12094,18 @@ class Item {
                 });
                 if (!waitForReady)
                     return proxiedInstance;
-                await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+                try {
+                    await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+                }
+                catch (err) {
+                    try {
+                        proxiedInstance.unload();
+                    }
+                    catch {
+                        /* best-effort cache cleanup */
+                    }
+                    throw err;
+                }
                 return proxiedInstance;
             }
         }
@@ -11700,7 +12277,18 @@ class Item {
         });
         if (!waitForReady)
             return proxiedInstance;
-        await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+        try {
+            await waitForEntityIdle(proxiedInstance, { timeout: readyTimeout });
+        }
+        catch (err) {
+            try {
+                proxiedInstance.unload();
+            }
+            catch {
+                /* best-effort cache cleanup */
+            }
+            throw err;
+        }
         return proxiedInstance;
     }
     /**
@@ -12135,8 +12723,16 @@ class Item {
             }
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
+            const itemActor = this._service;
+            const sendToItemMachine = (event) => {
+                const status = itemActor.getSnapshot().status;
+                if (status === 'stopped' || status === 'done') {
+                    return;
+                }
+                itemActor.send(event);
+            };
             try {
-                const _mod_8 = await import('./index-dDmXPEJC.js');
+                const _mod_8 = await import('./index-DdzhrbkF.js');
                 const _ns_8 = _mod_8.s;
                 const seedSchemaMod = _ns_8;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -12212,7 +12808,7 @@ class Item {
                     }
                 }
                 // Update context with latest version info
-                this._service.send({
+                sendToItemMachine({
                     type: 'updateContext',
                     latestVersionLocalId: currentVersionLocalId,
                     latestVersionUid: seedRecord.latestVersionUid,
@@ -12267,7 +12863,7 @@ class Item {
                             const seedRow = seedRows[0];
                             logger(`[Item._setupLiveQuerySubscription] Seed updated in database`);
                             // Update context with seed data
-                            this._service.send({
+                            sendToItemMachine({
                                 type: 'updateContext',
                                 seedLocalId: seedRow.localId,
                                 seedUid: seedRow.uid || undefined,
@@ -12338,7 +12934,7 @@ class Item {
                                                 modelName: itemModelName,
                                             });
                                             if (property) {
-                                                this._service.send({
+                                                sendToItemMachine({
                                                     type: 'addPropertyInstance',
                                                     propertyName,
                                                     propertyInstance: property,
@@ -12357,7 +12953,7 @@ class Item {
                                 }
                             }
                             // Update context with latest version info
-                            this._service.send({
+                            sendToItemMachine({
                                 type: 'updateContext',
                                 latestVersionLocalId,
                                 latestVersionUid: latestVersion.uid || undefined,
@@ -12447,7 +13043,7 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await import('./ownership-C7GyMbsf.js');
+        const { assertItemOwned } = await import('./ownership-BK6suksO.js');
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKey = context.seedUid || context.seedLocalId;
@@ -12508,37 +13104,6 @@ function normalizeAddressConfig(addresses) {
     };
 }
 
-const isNode = () => {
-    return (typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null);
-};
-const isBrowser = () => {
-    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
-};
-const isElectron = () => {
-    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
-};
-
-/**
- * @deprecated Use BaseArweaveClient.setHost() instead.
- * This function is kept for backward compatibility but will be removed in a future version.
- */
-const setArweaveDomain = (newDomain) => {
-    BaseArweaveClient.setHost(newDomain);
-};
-
-const logger$c = debug('seedSdk:services:events');
-const handleServiceSaveState = (event) => {
-    const { state, serviceId } = event;
-    logger$c(`[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))
-};
-const setupServicesEventHandlers = () => {
-    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
-};
-
 // Dynamic import to break circular dependency: Model -> BaseItem -> ... -> getModelSchemas -> Model
 // import { Model } from '@/Model/Model'
 const schemaStringToModelRecord = new Map();
@@ -13109,6 +13674,37 @@ const syncDbWithEasHandler = throttle(async (_) => {
     trailing: false,
 });
 
+const isNode = () => {
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
+};
+const isBrowser = () => {
+    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
+};
+const isElectron = () => {
+    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
+};
+
+/**
+ * @deprecated Use BaseArweaveClient.setHost() instead.
+ * This function is kept for backward compatibility but will be removed in a future version.
+ */
+const setArweaveDomain = (newDomain) => {
+    BaseArweaveClient.setHost(newDomain);
+};
+
+const logger$c = debug('seedSdk:services:events');
+const handleServiceSaveState = (event) => {
+    const { state, serviceId } = event;
+    logger$c(`[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))
+};
+const setupServicesEventHandlers = () => {
+    eventEmitter.addListener('service.saveState.request', handleServiceSaveState);
+};
+
 const setupAllItemsEventHandlers = () => {
     eventEmitter.addListener('syncDbWithEas', syncDbWithEasHandler);
 };
@@ -13182,20 +13778,20 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         let PathResolver;
         let EasClient;
         if (isBrowser()) {
-            FileManager = (await import('./FileManager-Ba1qAT8_.js')).FileManager;
-            Db = (await import('./Db-CCMLWMi-.js')).Db;
-            QueryClient = (await import('./QueryClient-BqpbpJEP.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-Ck4wflb3.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-B5XBxiLt.js')).PathResolver;
-            EasClient = (await import('./EasClient-Bqzb-xF2.js')).EasClient;
+            FileManager = (await import('./FileManager-DHnyb040.js')).FileManager;
+            Db = (await import('./Db-CXwQVLZv.js')).Db;
+            QueryClient = (await import('./QueryClient-unspcsWa.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-Cz9ZLiEV.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-pmw--Ea2.js')).PathResolver;
+            EasClient = (await import('./EasClient-DjpbHjU9.js')).EasClient;
         }
         else if (isNode()) {
-            FileManager = (await import('./FileManager-rVAH7uNp.js')).FileManager;
-            Db = (await import('./Db-YFg99EDt.js')).Db;
-            QueryClient = (await import('./QueryClient-5NAcOOvw.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-C1bakApw.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-CzhXp_OH.js')).PathResolver;
-            EasClient = (await import('./EasClient-BmYeAnq7.js')).EasClient;
+            FileManager = (await import('./FileManager-CKyoLrBP.js')).FileManager;
+            Db = (await import('./Db-DkTBncAM.js')).Db;
+            QueryClient = (await import('./QueryClient-OUjfvY3g.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-DxpJnJXU.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-Ce4K9acQ.js')).PathResolver;
+            EasClient = (await import('./EasClient-JYkmHxu1.js')).EasClient;
         }
         else {
             throw new Error(`Unable to determine environment. isBrowser()=${isBrowser()}, isNode()=${isNode()}. Platform-specific implementations could not be loaded.`);
@@ -13269,6 +13865,7 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
                 dbConfig,
                 schemaFile,
                 schema,
+                syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? false,
             } });
         if (arweaveDomain) {
             setArweaveDomain(arweaveDomain);
@@ -16192,8 +16789,64 @@ const processSchemaFiles = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
+/** Emitted by the client manager after `app_state.addresses` is written (post-`setAddresses`). */
+const ADDRESSES_PERSISTED_EVENT = 'addresses.persisted';
+function parseAddressesPersistedPayload(value) {
+    if (!value || typeof value !== 'object') {
+        return { owned: [], watched: [] };
+    }
+    const v = value;
+    const owned = Array.isArray(v.owned)
+        ? v.owned.filter((a) => typeof a === 'string')
+        : [];
+    const watched = Array.isArray(v.watched)
+        ? v.watched.filter((a) => typeof a === 'string')
+        : [];
+    return { owned, watched };
+}
+
 const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, } = ClientManagerState;
 const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
+const logSyncAfterAddressSave = debug("seedSdk:client:clientManagerMachine:syncAfterAddressSave");
+function addressesFromPersistedAddressValue(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const v = value;
+    const owned = Array.isArray(v.owned)
+        ? v.owned.filter((a) => typeof a === "string")
+        : [];
+    const watched = Array.isArray(v.watched)
+        ? v.watched.filter((a) => typeof a === "string")
+        : [];
+    const seen = new Set();
+    const out = [];
+    for (const a of [...owned, ...watched]) {
+        const k = a.toLowerCase();
+        if (!seen.has(k)) {
+            seen.add(k);
+            out.push(a);
+        }
+    }
+    return out;
+}
+function maybeRunSyncFromEasAfterAddressSave({ context, event, }) {
+    if (!context.syncFromEasOnAddressChange)
+        return;
+    if (event.key !== "addresses")
+        return;
+    const merged = addressesFromPersistedAddressValue(event.value);
+    if (merged.length === 0)
+        return;
+    void runSyncFromEas({ addresses: merged }).catch((err) => {
+        logSyncAfterAddressSave("runSyncFromEas after address save failed", err);
+    });
+}
+function emitAddressesPersistedIfAddressesKey(event) {
+    if (event.key !== "addresses")
+        return;
+    const payload = parseAddressesPersistedPayload(event.value);
+    eventEmitter.emit(ADDRESSES_PERSISTED_EVENT, payload);
+}
 const clientManagerMachine = setup({
     types: {
         context: {},
@@ -16352,12 +17005,18 @@ const clientManagerMachine = setup({
             }),
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
-                    actions: assign(({ event }) => {
-                        const { key, value } = event;
-                        return {
-                            isSaving: false
-                        };
-                    }),
+                    actions: [
+                        assign(({ event }) => {
+                            return {
+                                isSaving: false,
+                            };
+                        }),
+                        ({ context, event }) => maybeRunSyncFromEasAfterAddressSave({
+                            context,
+                            event: event,
+                        }),
+                        ({ event }) => emitAddressesPersistedIfAddressesKey(event),
+                    ],
                 },
                 [SET_ADDRESSES]: {
                     actions: [
@@ -16396,6 +17055,7 @@ const clientManager = createActor(clientManagerMachine, {
         isInitialized: false,
         addressesSet: false,
         isSaving: false,
+        syncFromEasOnAddressChange: false,
     }
 });
 const subscription = clientManager.subscribe((snapshot) => {
@@ -16444,6 +17104,7 @@ const clientInstance = {
                     isInitialized: false,
                     addressesSet: false,
                     isSaving: false,
+                    syncFromEasOnAddressChange: false,
                     endpoints: undefined,
                     addresses: undefined,
                     ownedAddresses: undefined,
@@ -16730,7 +17391,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-Csj84uQv.js')
+const modelPropertyImportPromise = import('./ModelProperty-DWtv9fQr.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -16747,7 +17408,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_9 = await import('./Schema-QjwZN91G.js'); return _mod_9.b; })()
+const schemaImportPromise = (async () => { const _mod_9 = await import('./Schema-CqqcEexA.js'); return _mod_9.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -18487,5 +19148,5 @@ var Model$1 = /*#__PURE__*/Object.freeze({
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 
-export { SEED_CONFIG_FILE as $, versions as A, Boolean$1 as B, modelPropertiesToObject as C, Date$1 as D, parseListPropertyValueFromStorage as E, File$1 as F, getCorrectId as G, INTERNAL_PROPERTY_NAMES as H, Image as I, Json as J, defaultAttestationData as K, List as L, Model as M, Number$1 as N, INTERNAL_DATA_TYPES as O, Property as P, toSnakeCase as Q, Relation as R, getEasSchemaUidForSchemaDefinition as S, TModelValues as T, getEasSchemaForItemProperty as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, getItemData as W, resolveStorageNameToSchemaName as X, appState as Y, ZERO_BYTES32 as Z, BasePathResolver as _, TModelSchema as a, SeedModels as a$, SEED_CONFIG_FALLBACKS as a0, BaseEasClient as a1, EAS_ENDPOINT as a2, BaseQueryClient as a3, arweaveL1FinalizeJobs as a4, config as a5, metadata$1 as a6, modelRelations as a7, modelSchemas as a8, modelUids as a9, waitForEntityIdle as aA, createReactiveProxy as aB, findEntity as aC, forceRemoveFromCaches as aD, runDestroyLifecycle as aE, getModelId as aF, getClient as aG, ClientManagerState as aH, MachineIds as aI, createNewItem as aJ, getVersionData$1 as aK, getMetadataLatest as aL, loadAllSchemasFromDb as aM, propertyMachine as aN, SEED_PROTOCOL_SCHEMA_NAME as aO, ImageSize as aP, setSchemaUidForSchemaDefinition as aQ, setSchemaUidForModel as aR, getModelSchemasFromEas as aS, getItemVersionsFromEas as aT, getItemPropertiesFromEas as aU, getCanonicalItemPropertiesFromEas as aV, getEasSchemaUidBySchemaName as aW, getSeedsFromSchemaUids as aX, getSeedsBySchemaName as aY, withExcludeRevokedFilter as aZ, pickLatestPropertyAttestationsByRefAndSchema as a_, modelsRelations as aa, propertiesRelations as ab, propertyUidRelations as ac, propertyUids as ad, publishProcesses as ae, schemas as af, uploadProcesses as ag, graphql as ah, getPropertyIdForModelAndName as ai, saveAppState as aj, addModelsToDb$1 as ak, SCHEMA_NJK as al, ItemProperty as am, eventEmitter as an, ClientManager as ao, INIT_SCRIPT_SUCCESS_MESSAGE as ap, SCHEMA_TS as aq, getRefValueType as ar, importJsonSchema as as, loadSchemaFromFile as at, readJsonImportFile as au, syncSchemaFromSource as av, transformImportToSchemaFile as aw, writeProcessMachine as ax, getModelIdByFileId as ay, generateId as az, ModelPropertyDataTypes as b, DEFAULT_ARWEAVE_HOST as b0, DEFAULT_ARWEAVE_GATEWAYS as b1, DEFAULT_ARWEAVE_GRAPHQL_URL as b2, updateSeedRevokedAt as b3, getAddressesForItemsFilter as b4, getArweaveUrlForTransaction as b5, normalizeUploadApiBaseUrl as b6, getUploadApiArweaveDataUrl as b7, getUploadPipelineTransactionStatus as b8, getUploadApiArweaveStatusUrl as b9, db as bA, eas as bB, getPropertyData$1 as bC, schema as bD, SEEDPROTOCOL_Seed_Protocol_v1 as bE, Model$1 as bF, getArweaveUploadStatus as ba, isArweaveL1AnchoringComplete as bb, queryArweaveGatewayTransaction as bc, setUploadExecutor as bd, getUploadExecutor as be, setGetPublisherForNewSeeds as bf, getGetPublisherForNewSeeds as bg, setRevokeExecutor as bh, getRevokeExecutor as bi, setAdditionalSyncAddresses as bj, createSchema as bk, readSchema as bl, listCompleteSchemaFiles as bm, getSchemaNameFromId as bn, addSchemaToDb as bo, createModelsFromJson as bp, loadModelsFromDbForSchema as bq, getLatestSchemaVersion as br, isInternalSchema as bs, createModelFromJson as bt, ConflictError as bu, unloadEntity as bv, clearDestroySubscriptions as bw, setupEntityLiveQuery as bx, ModelSchema as by, BaseFileManager$1 as bz, TPropertyDataType as c, TStorageType as d, TProperty as e, TPropertyConstructor as f, TPropertyDefs as g, PropertyMetadataKey as h, PropertyConstructor as i, Text as j, DEFAULT_TEXT_MAX_LENGTH as k, TValidationRules as l, getOwnedAddressesFromDb as m, normalizeDataType as n, BaseDb as o, getGetAdditionalSyncAddresses as p, normalizeRelationPropertyValue as q, resolveSeedIdsFromRefString as r, seeds as s, Item as t, BaseFileManager as u, getContentHash as v, BaseArweaveClient as w, getEasSchemaUidForModel as x, models$1 as y, properties as z };
-//# sourceMappingURL=index-C1HlP_fU.js.map
+export { getItemData as $, models$1 as A, Boolean$1 as B, properties as C, Date$1 as D, isValidEasAttestationUid as E, File$1 as F, getLatestPublishedVersionRow as G, Html as H, Image as I, Json as J, modelPropertiesToObject as K, List as L, Model as M, Number$1 as N, parseListPropertyValueFromStorage as O, Property as P, getCorrectId as Q, Relation as R, INTERNAL_PROPERTY_NAMES as S, TModelValues as T, defaultAttestationData as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, INTERNAL_DATA_TYPES as W, toSnakeCase as X, getEasSchemaUidForSchemaDefinition as Y, ZERO_BYTES32 as Z, getEasSchemaForItemProperty as _, TModelSchema as a, setSchemaUidForModel as a$, resolveStorageNameToSchemaName as a0, appState as a1, BasePathResolver as a2, SEED_CONFIG_FILE as a3, SEED_CONFIG_FALLBACKS as a4, BaseEasClient as a5, EAS_ENDPOINT as a6, BaseQueryClient as a7, arweaveL1FinalizeJobs as a8, config as a9, syncSchemaFromSource as aA, transformImportToSchemaFile as aB, writeProcessMachine as aC, getModelIdByFileId as aD, generateId as aE, waitForEntityIdle as aF, createReactiveProxy as aG, findEntity as aH, forceRemoveFromCaches as aI, runDestroyLifecycle as aJ, getModelId as aK, isPlaceholderUid as aL, normalizeBytes32Hex as aM, getArweaveUrlForTransaction as aN, ADDRESSES_PERSISTED_EVENT as aO, parseAddressesPersistedPayload as aP, getClient as aQ, ClientManagerState as aR, MachineIds as aS, createNewItem as aT, getVersionData$1 as aU, getMetadataLatest as aV, loadAllSchemasFromDb as aW, propertyMachine as aX, SEED_PROTOCOL_SCHEMA_NAME as aY, ImageSize as aZ, setSchemaUidForSchemaDefinition as a_, metadata$1 as aa, modelRelations as ab, modelSchemas as ac, modelUids as ad, modelsRelations as ae, propertiesRelations as af, propertyUidRelations as ag, propertyUids as ah, publishProcesses as ai, schemas as aj, uploadProcesses as ak, versions as al, graphql as am, getPropertyIdForModelAndName as an, saveAppState as ao, addModelsToDb$1 as ap, SCHEMA_NJK as aq, ItemProperty as ar, eventEmitter as as, ClientManager as at, INIT_SCRIPT_SUCCESS_MESSAGE as au, SCHEMA_TS as av, getRefValueType as aw, importJsonSchema as ax, loadSchemaFromFile as ay, readJsonImportFile as az, ModelPropertyDataTypes as b, getModelSchemasFromEas as b0, getItemVersionsFromEas as b1, getItemPropertiesFromEas as b2, getCanonicalItemPropertiesFromEas as b3, getEasSchemaUidBySchemaName as b4, getSeedsFromSchemaUids as b5, getSeedsBySchemaName as b6, withExcludeRevokedFilter as b7, classifyMediaRef as b8, resolveMediaRef as b9, getSchemaNameFromId as bA, addSchemaToDb as bB, createModelsFromJson as bC, loadModelsFromDbForSchema as bD, getLatestSchemaVersion as bE, isInternalSchema as bF, createModelFromJson as bG, ConflictError as bH, unloadEntity as bI, clearDestroySubscriptions as bJ, setupEntityLiveQuery as bK, ModelSchema as bL, BaseFileManager$1 as bM, db as bN, eas as bO, getPropertyData$1 as bP, schema as bQ, SEEDPROTOCOL_Seed_Protocol_v1 as bR, Model$1 as bS, normalizeFeedItemFields as ba, getFeedItemStringField as bb, pickLatestPropertyAttestationsByRefAndSchema as bc, SeedModels as bd, DEFAULT_ARWEAVE_HOST as be, DEFAULT_ARWEAVE_GATEWAYS as bf, DEFAULT_ARWEAVE_GRAPHQL_URL as bg, updateSeedRevokedAt as bh, getAddressesForItemsFilter as bi, normalizeUploadApiBaseUrl as bj, getUploadApiArweaveDataUrl as bk, getUploadPipelineTransactionStatus as bl, getUploadApiArweaveStatusUrl as bm, getArweaveUploadStatus as bn, isArweaveL1AnchoringComplete as bo, queryArweaveGatewayTransaction as bp, setUploadExecutor as bq, getUploadExecutor as br, setGetPublisherForNewSeeds as bs, getGetPublisherForNewSeeds as bt, setRevokeExecutor as bu, getRevokeExecutor as bv, setAdditionalSyncAddresses as bw, createSchema as bx, readSchema as by, listCompleteSchemaFiles as bz, TPropertyDataType as c, TStorageType as d, THtmlEmbeddedDataUriPolicy as e, TProperty as f, TPropertyConstructor as g, TPropertyDefs as h, PropertyMetadataKey as i, PropertyConstructor as j, Text as k, DEFAULT_TEXT_MAX_LENGTH as l, TValidationRules as m, normalizeDataType as n, getOwnedAddressesFromDb as o, BaseDb as p, getGetAdditionalSyncAddresses as q, resolveSeedIdsFromRefString as r, seeds as s, normalizeRelationPropertyValue as t, Item as u, BaseFileManager as v, getContentHash as w, htmlEmbeddedImageCoPublish as x, BaseArweaveClient as y, getEasSchemaUidForModel as z };
+//# sourceMappingURL=index-BrD_NNaX.js.map