@seedprotocol/sdk 0.4.19 → 0.4.21

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

@@ -345,6 +345,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',
@@ -423,6 +425,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,
@@ -602,14 +605,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 };
         }
@@ -621,7 +629,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 };
     }
 }
@@ -763,8 +775,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') {
@@ -781,13 +803,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`);
     }
 }
@@ -939,6 +966,11 @@ const TStorageType = typebox.Type.Union([
     typebox.Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
     typebox.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 = typebox.Type.Union([
+    typebox.Type.Literal('materialize'),
+    typebox.Type.Literal('preserve'),
+]);
 const TProperty = typebox.Type.Object({
     id: typebox.Type.Optional(typebox.Type.String()), // schemaFileId (string) - public ID
     _dbId: typebox.Type.Optional(typebox.Type.Number()), // Database integer ID - internal only
@@ -956,6 +988,8 @@ const TProperty = typebox.Type.Object({
     filenameSuffix: typebox.Type.Optional(typebox.Type.String()),
     validation: typebox.Type.Optional(TValidationRules),
     required: typebox.Type.Optional(typebox.Type.Boolean()),
+    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
+    htmlEmbeddedDataUriPolicy: typebox.Type.Optional(THtmlEmbeddedDataUriPolicy),
 });
 const TPropertyConstructor = typebox.Type.Function([
     typebox.Type.Optional(typebox.Type.Union([typebox.Type.String(), TStorageType, typebox.Type.Undefined()])),
@@ -963,6 +997,14 @@ const TPropertyConstructor = typebox.Type.Function([
     typebox.Type.Optional(typebox.Type.Union([typebox.Type.String(), typebox.Type.Boolean()])),
 ], TProperty);
 const TPropertyDefs = typebox.Type.Record(TPropertyDataType, TPropertyConstructor);
+function htmlPropertyFactory(opts) {
+    return {
+        dataType: exports.ModelPropertyDataTypes.Html,
+        ...(opts?.htmlEmbeddedDataUriPolicy
+            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
+            : {}),
+    };
+}
 const Property = {
     Text: (storageType, localStorageDir, filenameSuffix) => ({
         dataType: exports.ModelPropertyDataTypes.Text,
@@ -995,7 +1037,8 @@ const Property = {
     Image: () => ({ dataType: exports.ModelPropertyDataTypes.Image }),
     Boolean: () => ({ dataType: exports.ModelPropertyDataTypes.Boolean }),
     Date: () => ({ dataType: exports.ModelPropertyDataTypes.Date }),
-    Html: () => ({ dataType: exports.ModelPropertyDataTypes.Html }),
+    Html: htmlPropertyFactory,
+    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
 };
 const PropertyMetadataKey = Symbol('property');
 const PropertyConstructor = (propertyType) => {
@@ -1014,6 +1057,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
@@ -1188,7 +1232,505 @@ function resolveSeedIdsFromRefString(s) {
     if (LOCAL_SEED_REF.test(s) && !s.startsWith('0x')) {
         return { seedLocalId: s };
     }
-    return {};
+    return {};
+}
+
+const seeds = sqliteCore.sqliteTable('seeds', {
+    localId: sqliteCore.text('local_id').unique(),
+    uid: sqliteCore.text('uid'),
+    schemaUid: sqliteCore.text('schema_uid'),
+    type: sqliteCore.text('type'),
+    publisher: sqliteCore.text('publisher'),
+    attestationRaw: sqliteCore.text('attestation_raw'),
+    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+    _markedForDeletion: sqliteCore.int('_marked_for_deletion'),
+    revokedAt: sqliteCore.int('revoked_at'),
+});
+
+const versions = sqliteCore.sqliteTable('versions', {
+    localId: sqliteCore.text('local_id').unique(),
+    uid: sqliteCore.text('uid'),
+    seedLocalId: sqliteCore.text('seed_local_id'),
+    seedUid: sqliteCore.text('seed_uid'),
+    seedType: sqliteCore.text('seed_type'),
+    note: sqliteCore.text('note'),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
+    attestationRaw: sqliteCore.text('attestation_raw'),
+    publisher: sqliteCore.text('publisher'),
+});
+
+const metadata$1 = sqliteCore.sqliteTable('metadata', {
+    localId: sqliteCore.text('local_id').unique(),
+    uid: sqliteCore.text('uid'),
+    propertyId: sqliteCore.integer('property_id').references(() => properties.id),
+    propertyName: sqliteCore.text('property_name'),
+    propertyValue: sqliteCore.text('property_value'),
+    schemaUid: sqliteCore.text('schema_uid'),
+    modelType: sqliteCore.text('model_type'),
+    seedLocalId: sqliteCore.text('seed_local_id'),
+    seedUid: sqliteCore.text('seed_uid'),
+    versionLocalId: sqliteCore.text('version_local_id'),
+    versionUid: sqliteCore.text('version_uid'),
+    easDataType: sqliteCore.text('eas_data_type'),
+    refValueType: sqliteCore.text('ref_value_type'),
+    refModelUid: sqliteCore.text('ref_schema_uid'),
+    refSeedType: sqliteCore.text('ref_seed_type'),
+    refResolvedValue: sqliteCore.text('ref_resolved_value'),
+    refResolvedDisplayValue: sqliteCore.text('ref_resolved_display_value'),
+    localStorageDir: sqliteCore.text('local_storage_dir'),
+    attestationRaw: sqliteCore.text('attestation_raw'),
+    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
+    contentHash: sqliteCore.text('content_hash'),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+    publisher: sqliteCore.text('publisher'),
+});
+
+const appState = sqliteCore.sqliteTable('appState', {
+    key: sqliteCore.text('key').unique(),
+    value: sqliteCore.text('value'),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+});
+
+const modelUids = sqliteCore.sqliteTable('model_uids', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    uid: sqliteCore.text('uid').notNull(),
+    modelId: sqliteCore.int('model_id')
+        .notNull()
+        .unique()
+        .references(() => models$1.id),
+});
+const modelRelations = drizzleOrm.relations(modelUids, ({ one }) => ({
+    model: one(models$1),
+}));
+
+const propertyUids = sqliteCore.sqliteTable('property_uids', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    uid: sqliteCore.text('uid').notNull(),
+    propertyId: sqliteCore.int('property_id')
+        .notNull()
+        .unique()
+        .references(() => properties.id),
+});
+const propertyUidRelations = drizzleOrm.relations(propertyUids, ({ one }) => ({
+    property: one(properties),
+}));
+
+const config = sqliteCore.sqliteTable('config', {
+    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
+    key: sqliteCore.text('key').notNull(),
+    text: sqliteCore.text('text'),
+    json: sqliteCore.text('json'),
+    blob: sqliteCore.blob('blob'),
+});
+
+const schemas = sqliteCore.sqliteTable('schemas', {
+    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
+    name: sqliteCore.text('name').notNull(),
+    version: sqliteCore.integer('version').notNull(),
+    schemaFileId: sqliteCore.text('schema_file_id'), // ID from JSON file for change tracking - must be unique
+    schemaData: sqliteCore.text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
+    isDraft: sqliteCore.integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
+    isEdited: sqliteCore.integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+}, (table) => {
+    return {
+        uniqueSchemaFileId: sqliteCore.unique('unique_schema_schema_file_id').on(table.schemaFileId),
+    };
+});
+
+var SchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    schemas: schemas
+});
+
+const modelSchemas = sqliteCore.sqliteTable('model_schemas', {
+    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
+    modelId: sqliteCore.integer('model_id').references(() => models$1.id),
+    schemaId: sqliteCore.integer('schema_id').references(() => schemas.id),
+});
+
+var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    modelSchemas: modelSchemas
+});
+
+const publishProcesses = sqliteCore.sqliteTable('publish_processes', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: sqliteCore.text('seed_local_id').notNull(),
+    modelName: sqliteCore.text('model_name').notNull(),
+    schemaId: sqliteCore.text('schema_id'),
+    status: sqliteCore.text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
+    startedAt: sqliteCore.int('started_at').notNull(),
+    completedAt: sqliteCore.int('completed_at'),
+    errorMessage: sqliteCore.text('error_message'),
+    errorStep: sqliteCore.text('error_step'),
+    errorDetails: sqliteCore.text('error_details'),
+    persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(),
+    seedId: sqliteCore.text('seed_id'),
+    existingSeedUid: sqliteCore.text('existing_seed_uid'),
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+});
+
+const uploadProcesses = sqliteCore.sqliteTable('upload_processes', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    reimbursementConfirmed: sqliteCore.int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
+    reimbursementTransactionId: sqliteCore.text('reimbursement_transaction_id'),
+    transactionKeys: sqliteCore.text('transaction_keys'),
+    persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(), // JSON string
+    createdAt: sqliteCore.int('created_at'),
+    updatedAt: sqliteCore.int('updated_at'),
+});
+
+/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
+const arweaveL1FinalizeJobs = sqliteCore.sqliteTable('arweave_l1_finalize_jobs', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    seedLocalId: sqliteCore.text('seed_local_id').notNull(),
+    dataItemId: sqliteCore.text('data_item_id').notNull(),
+    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
+    l1TransactionId: sqliteCore.text('l1_transaction_id'),
+    bundleId: sqliteCore.text('bundle_id'),
+    versionLocalId: sqliteCore.text('version_local_id'),
+    itemPropertyName: sqliteCore.text('item_property_name'),
+    /** `pending_l1` | `confirmed` | `failed` */
+    phase: sqliteCore.text('phase').notNull(),
+    statusJson: sqliteCore.text('status_json'),
+    errorMessage: sqliteCore.text('error_message'),
+    createdAt: sqliteCore.int('created_at').notNull(),
+    updatedAt: sqliteCore.int('updated_at').notNull(),
+}, (table) => ({
+    dataItemIdUnique: sqliteCore.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 = sqliteCore.sqliteTable('html_embedded_image_co_publish', {
+    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
+    parentSeedLocalId: sqliteCore.text('parent_seed_local_id').notNull(),
+    htmlSeedLocalId: sqliteCore.text('html_seed_local_id').notNull(),
+    imageSeedLocalId: sqliteCore.text('image_seed_local_id').notNull(),
+    /** Stable dedup key (e.g. sha256 of data URI or normalized URI string). */
+    stableKey: sqliteCore.text('stable_key').notNull(),
+    createdAt: sqliteCore.int('created_at').notNull(),
+}, (t) => [
+    sqliteCore.uniqueIndex('html_embed_co_pub_parent_html_stable').on(t.parentSeedLocalId, t.htmlSeedLocalId, t.stableKey),
+]);
+
+var schema$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    appState: appState,
+    arweaveL1FinalizeJobs: arweaveL1FinalizeJobs,
+    config: config,
+    htmlEmbeddedImageCoPublish: htmlEmbeddedImageCoPublish,
+    metadata: metadata$1,
+    modelRelations: modelRelations,
+    modelSchemas: modelSchemas,
+    modelUids: modelUids,
+    models: models$1,
+    modelsRelations: modelsRelations,
+    properties: properties,
+    propertiesRelations: propertiesRelations,
+    propertyUidRelations: propertyUidRelations,
+    propertyUids: propertyUids,
+    publishProcesses: publishProcesses,
+    schemas: schemas,
+    seeds: seeds,
+    uploadProcesses: uploadProcesses,
+    versions: versions
+});
+
+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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedUid, seedUid), drizzleOrm.eq(metadata$1.propertyName, 'storageTransactionId'))));
+    if (!results || results.length === 0) {
+        return;
+    }
+    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
+    return results[0].storageTransactionId;
+};
+
+const logger$A = 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$A(`[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 out;
+}
+
+/**
+ * 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) {
@@ -1378,6 +1920,7 @@ var index = /*#__PURE__*/Object.freeze({
     BaseFileManager: BaseFileManager,
     BaseQueryClient: BaseQueryClient,
     capitalizeFirstLetter: capitalizeFirstLetter,
+    classifyMediaRef: classifyMediaRef,
     convertTxIdToImage: convertTxIdToImage,
     generateId: generateId,
     getAlternatePropertyNameForInstanceLookup: getAlternatePropertyNameForInstanceLookup,
@@ -1386,6 +1929,7 @@ var index = /*#__PURE__*/Object.freeze({
     getCorrectId: getCorrectId,
     getDataTypeFromString: getDataTypeFromString,
     getExecutionTime: getExecutionTime,
+    getFeedItemStringField: getFeedItemStringField,
     getGetAdditionalSyncAddresses: getGetAdditionalSyncAddresses,
     getGetPublisherForNewSeeds: getGetPublisherForNewSeeds,
     getMetadataPropertyNamesForQuery: getMetadataPropertyNamesForQuery,
@@ -1399,13 +1943,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,
@@ -1431,7 +1980,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Cuj839nX.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$y('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -1615,7 +2164,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1859,7 +2408,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1903,10 +2452,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -2016,7 +2565,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$w(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Cuj839nX.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$w('ModelProperty not available from dynamic import');
@@ -2120,7 +2669,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$v(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -2138,7 +2687,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$v(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -2174,7 +2723,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -2189,7 +2738,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -2218,7 +2767,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -2247,202 +2796,6 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     // @ts-ignore - XState v5 type inference bug: fromPromise incorrectly expects output type to match input type
 });
 
-const seeds = sqliteCore.sqliteTable('seeds', {
-    localId: sqliteCore.text('local_id').unique(),
-    uid: sqliteCore.text('uid'),
-    schemaUid: sqliteCore.text('schema_uid'),
-    type: sqliteCore.text('type'),
-    publisher: sqliteCore.text('publisher'),
-    attestationRaw: sqliteCore.text('attestation_raw'),
-    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-    _markedForDeletion: sqliteCore.int('_marked_for_deletion'),
-    revokedAt: sqliteCore.int('revoked_at'),
-});
-
-const versions = sqliteCore.sqliteTable('versions', {
-    localId: sqliteCore.text('local_id').unique(),
-    uid: sqliteCore.text('uid'),
-    seedLocalId: sqliteCore.text('seed_local_id'),
-    seedUid: sqliteCore.text('seed_uid'),
-    seedType: sqliteCore.text('seed_type'),
-    note: sqliteCore.text('note'),
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
-    attestationRaw: sqliteCore.text('attestation_raw'),
-    publisher: sqliteCore.text('publisher'),
-});
-
-const metadata$1 = sqliteCore.sqliteTable('metadata', {
-    localId: sqliteCore.text('local_id').unique(),
-    uid: sqliteCore.text('uid'),
-    propertyId: sqliteCore.integer('property_id').references(() => properties.id),
-    propertyName: sqliteCore.text('property_name'),
-    propertyValue: sqliteCore.text('property_value'),
-    schemaUid: sqliteCore.text('schema_uid'),
-    modelType: sqliteCore.text('model_type'),
-    seedLocalId: sqliteCore.text('seed_local_id'),
-    seedUid: sqliteCore.text('seed_uid'),
-    versionLocalId: sqliteCore.text('version_local_id'),
-    versionUid: sqliteCore.text('version_uid'),
-    easDataType: sqliteCore.text('eas_data_type'),
-    refValueType: sqliteCore.text('ref_value_type'),
-    refModelUid: sqliteCore.text('ref_schema_uid'),
-    refSeedType: sqliteCore.text('ref_seed_type'),
-    refResolvedValue: sqliteCore.text('ref_resolved_value'),
-    refResolvedDisplayValue: sqliteCore.text('ref_resolved_display_value'),
-    localStorageDir: sqliteCore.text('local_storage_dir'),
-    attestationRaw: sqliteCore.text('attestation_raw'),
-    attestationCreatedAt: sqliteCore.int('attestation_created_at'),
-    contentHash: sqliteCore.text('content_hash'),
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-    publisher: sqliteCore.text('publisher'),
-});
-
-const appState = sqliteCore.sqliteTable('appState', {
-    key: sqliteCore.text('key').unique(),
-    value: sqliteCore.text('value'),
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-});
-
-const modelUids = sqliteCore.sqliteTable('model_uids', {
-    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
-    uid: sqliteCore.text('uid').notNull(),
-    modelId: sqliteCore.int('model_id')
-        .notNull()
-        .unique()
-        .references(() => models$1.id),
-});
-const modelRelations = drizzleOrm.relations(modelUids, ({ one }) => ({
-    model: one(models$1),
-}));
-
-const propertyUids = sqliteCore.sqliteTable('property_uids', {
-    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
-    uid: sqliteCore.text('uid').notNull(),
-    propertyId: sqliteCore.int('property_id')
-        .notNull()
-        .unique()
-        .references(() => properties.id),
-});
-const propertyUidRelations = drizzleOrm.relations(propertyUids, ({ one }) => ({
-    property: one(properties),
-}));
-
-const config = sqliteCore.sqliteTable('config', {
-    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
-    key: sqliteCore.text('key').notNull(),
-    text: sqliteCore.text('text'),
-    json: sqliteCore.text('json'),
-    blob: sqliteCore.blob('blob'),
-});
-
-const schemas = sqliteCore.sqliteTable('schemas', {
-    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
-    name: sqliteCore.text('name').notNull(),
-    version: sqliteCore.integer('version').notNull(),
-    schemaFileId: sqliteCore.text('schema_file_id'), // ID from JSON file for change tracking - must be unique
-    schemaData: sqliteCore.text('schema_data'), // Full JSON schema content (SchemaFileFormat as JSON string)
-    isDraft: sqliteCore.integer('is_draft', { mode: 'boolean' }), // true if schema is in draft/editing state, false if published to file
-    isEdited: sqliteCore.integer('is_edited', { mode: 'boolean' }), // true if schema has been edited locally, false if matches schema file
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-}, (table) => {
-    return {
-        uniqueSchemaFileId: sqliteCore.unique('unique_schema_schema_file_id').on(table.schemaFileId),
-    };
-});
-
-var SchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    schemas: schemas
-});
-
-const modelSchemas = sqliteCore.sqliteTable('model_schemas', {
-    id: sqliteCore.integer('id').primaryKey({ autoIncrement: true }),
-    modelId: sqliteCore.integer('model_id').references(() => models$1.id),
-    schemaId: sqliteCore.integer('schema_id').references(() => schemas.id),
-});
-
-var ModelSchemaSchema = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    modelSchemas: modelSchemas
-});
-
-const publishProcesses = sqliteCore.sqliteTable('publish_processes', {
-    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: sqliteCore.text('seed_local_id').notNull(),
-    modelName: sqliteCore.text('model_name').notNull(),
-    schemaId: sqliteCore.text('schema_id'),
-    status: sqliteCore.text('status').notNull(), // 'in_progress' | 'completed' | 'failed' | 'interrupted'
-    startedAt: sqliteCore.int('started_at').notNull(),
-    completedAt: sqliteCore.int('completed_at'),
-    errorMessage: sqliteCore.text('error_message'),
-    errorStep: sqliteCore.text('error_step'),
-    errorDetails: sqliteCore.text('error_details'),
-    persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(),
-    seedId: sqliteCore.text('seed_id'),
-    existingSeedUid: sqliteCore.text('existing_seed_uid'),
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-});
-
-const uploadProcesses = sqliteCore.sqliteTable('upload_processes', {
-    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
-    reimbursementConfirmed: sqliteCore.int('reimbursement_confirmed').notNull(), // 0 or 1 for boolean
-    reimbursementTransactionId: sqliteCore.text('reimbursement_transaction_id'),
-    transactionKeys: sqliteCore.text('transaction_keys'),
-    persistedSnapshot: sqliteCore.text('persisted_snapshot').notNull(), // JSON string
-    createdAt: sqliteCore.int('created_at'),
-    updatedAt: sqliteCore.int('updated_at'),
-});
-
-/** Background job: resolve L1 tx id and wait for L1 confirmation after bundler publish. */
-const arweaveL1FinalizeJobs = sqliteCore.sqliteTable('arweave_l1_finalize_jobs', {
-    id: sqliteCore.int('id').primaryKey({ autoIncrement: true }),
-    seedLocalId: sqliteCore.text('seed_local_id').notNull(),
-    dataItemId: sqliteCore.text('data_item_id').notNull(),
-    /** L1 bundle / anchor transaction id from gateway GraphQL `bundledIn.id`. */
-    l1TransactionId: sqliteCore.text('l1_transaction_id'),
-    bundleId: sqliteCore.text('bundle_id'),
-    versionLocalId: sqliteCore.text('version_local_id'),
-    itemPropertyName: sqliteCore.text('item_property_name'),
-    /** `pending_l1` | `confirmed` | `failed` */
-    phase: sqliteCore.text('phase').notNull(),
-    statusJson: sqliteCore.text('status_json'),
-    errorMessage: sqliteCore.text('error_message'),
-    createdAt: sqliteCore.int('created_at').notNull(),
-    updatedAt: sqliteCore.int('updated_at').notNull(),
-}, (table) => ({
-    dataItemIdUnique: sqliteCore.uniqueIndex('arweave_l1_finalize_jobs_data_item_id_unique').on(table.dataItemId),
-}));
-
-var schema$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    appState: appState,
-    arweaveL1FinalizeJobs: arweaveL1FinalizeJobs,
-    config: config,
-    metadata: metadata$1,
-    modelRelations: modelRelations,
-    modelSchemas: modelSchemas,
-    modelUids: modelUids,
-    models: models$1,
-    modelsRelations: modelsRelations,
-    properties: properties,
-    propertiesRelations: propertiesRelations,
-    propertyUidRelations: propertyUidRelations,
-    propertyUids: propertyUids,
-    publishProcesses: publishProcesses,
-    schemas: schemas,
-    seeds: seeds,
-    uploadProcesses: uploadProcesses,
-    versions: versions
-});
-
 const logger$u = debug('seedSdk:helpers:db');
 /**
  * Resolve property_id from model name/type and property name.
@@ -4366,7 +4719,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Cuj839nX.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -4746,7 +5099,7 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-Cuj839nX.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -5780,9 +6133,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;
@@ -5797,12 +6150,12 @@ const hydrateNewItem = xstate.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(() => {
@@ -5934,28 +6287,145 @@ const reload = xstate.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: drizzleOrm.count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: drizzleOrm.max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
+        lastLocalUpdateAt: drizzleOrm.max(versions.createdAt).as('lastLocalUpdateAt'),
+        maxCreatedAt: drizzleOrm.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: drizzleOrm.max(versions.localId).as('latestVersionLocalId'),
+    })
+        .from(versions)
+        .innerJoin(versionStats, drizzleOrm.and(drizzleOrm.eq(versions.seedLocalId, versionStats.seedLocalId), drizzleOrm.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, drizzleOrm.eq(versionStats.seedLocalId, latestVersionIds.seedLocalId))
+        .innerJoin(versions, drizzleOrm.and(drizzleOrm.eq(versions.seedLocalId, latestVersionIds.seedLocalId), drizzleOrm.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 = drizzleOrm.or(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId), drizzleOrm.eq(metadata$1.seedUid, seedUid));
+        if (orClause)
+            whereClauses.push(orClause);
+    }
+    else if (seedLocalId) {
+        whereClauses.push(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId));
+    }
+    else if (seedUid) {
+        whereClauses.push(drizzleOrm.eq(metadata$1.seedUid, seedUid));
+    }
+    const metadataColumns = drizzleOrm.getTableColumns(metadata$1);
+    return appDb.$with('metadataLatest').as(appDb
         .select({
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-        latestVersionUid: versions.uid,
-        latestVersionLocalId: versions.localId,
-        versionsCount: drizzleOrm.count(versions.localId).as('versionsCount'),
-        lastVersionPublishedAt: drizzleOrm.max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-        lastLocalUpdateAt: drizzleOrm.max(versions.createdAt).as('lastLocalUpdateAt'),
+        ...metadataColumns,
+        rowNum: drizzleOrm.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(drizzleOrm.and(...whereClauses)));
 };
 
-var versionData = /*#__PURE__*/Object.freeze({
+var metadataLatest = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getVersionData: getVersionData$1
+    getMetadataLatest: getMetadataLatest
 });
 
 const logger$q = 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
@@ -5991,7 +6461,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -6040,13 +6510,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.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]) {
@@ -6055,17 +6526,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) {
@@ -6089,7 +6557,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6279,18 +6747,26 @@ const loadOrCreateItem = xstate.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedLocalId, resolvedSeedLocalId), drizzleOrm.eq(metadata$1.versionLocalId, latestVersionLocalId)));
-        logger$q(`Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
+            .from(metadataLatest)
+            .where(drizzleOrm.eq(metadataLatest.rowNum, 1));
+        logger$q(`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',
@@ -6307,6 +6783,7 @@ const loadOrCreateItem = xstate.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,
             },
@@ -6337,9 +6814,9 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdSwst2x.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdVy-5fK.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-h_Rz8nVX.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DP2fm4q8.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6631,40 +7108,6 @@ const itemMachineSingle = xstate.setup({
     },
 });
 
-const getMetadataLatest = ({ seedLocalId, seedUid }) => {
-    const appDb = BaseDb.getAppDb();
-    const whereClauses = [];
-    if (seedLocalId && seedUid) {
-        const orClause = drizzleOrm.or(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId), drizzleOrm.eq(metadata$1.seedUid, seedUid));
-        if (orClause)
-            whereClauses.push(orClause);
-    }
-    else if (seedLocalId) {
-        whereClauses.push(drizzleOrm.eq(metadata$1.seedLocalId, seedLocalId));
-    }
-    else if (seedUid) {
-        whereClauses.push(drizzleOrm.eq(metadata$1.seedUid, seedUid));
-    }
-    const metadataColumns = drizzleOrm.getTableColumns(metadata$1);
-    return appDb.$with('metadataLatest').as(appDb
-        .select({
-        ...metadataColumns,
-        rowNum: drizzleOrm.sql.raw(`
-           ROW_NUMBER() OVER (
-               PARTITION BY property_name 
-               ORDER BY COALESCE(attestation_created_at, created_at) DESC
-           )
-          `).as('rowNum')
-    })
-        .from(metadata$1)
-        .where(drizzleOrm.and(...whereClauses)));
-};
-
-var metadataLatest = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getMetadataLatest: getMetadataLatest
-});
-
 const getItemProperties = async ({ seedLocalId, seedUid, edited, }) => {
     const appDb = BaseDb.getAppDb();
     const whereClauses = [drizzleOrm.isNotNull(metadata$1.propertyName)];
@@ -6719,6 +7162,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(drizzleOrm.eq(versions.seedLocalId, seedLocalId))
+        .orderBy(drizzleOrm.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$o = debug('seedSdk:db:read:getItemData');
 const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (!seedLocalId && !seedUid) {
@@ -6787,21 +7259,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: drizzleOrm.count(versions.localId).as('versionsCount'),
-            lastVersionPublishedAt: drizzleOrm.max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-            latestVersionUid: drizzleOrm.max(versions.uid).as('latestVersionUid'),
-            latestVersionLocalId: drizzleOrm.max(versions.localId).as('latestVersionLocalId'),
+            localId: versions.localId,
+            uid: versions.uid,
+            createdAt: versions.createdAt,
+            attestationCreatedAt: versions.attestationCreatedAt,
         })
             .from(versions)
-            .where(drizzleOrm.eq(versions.seedLocalId, resolvedSeedLocalId))
-            .groupBy(versions.seedLocalId)
-            .limit(1);
-        if (versionRows && versionRows.length > 0) {
-            versionRow = versionRows[0];
+            .where(drizzleOrm.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) {
@@ -6833,11 +7335,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(drizzleOrm.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(drizzleOrm.or(drizzleOrm.isNull(seeds.uid), drizzleOrm.eq(seeds.uid, '')));
+        conditions.push(drizzleOrm.or(drizzleOrm.isNull(seeds.uid), drizzleOrm.eq(seeds.uid, ''), drizzleOrm.eq(seeds.uid, 'NULL'), drizzleOrm.eq(seeds.uid, ZERO_BYTES32)));
     }
     if (modelName) {
         conditions.push(drizzleOrm.eq(seeds.type, casing.toSnakeCase(modelName)));
@@ -6886,10 +7442,20 @@ const getItemsData = async ({ modelName, deleted, includeEas = false, addressFil
         .from(seeds)
         .leftJoin(versionData, drizzleOrm.eq(seeds.localId, versionData.seedLocalId))
         .where(drizzleOrm.and(drizzleOrm.gt(versionData.versionsCount, 0), ...conditions))
-        .orderBy(drizzleOrm.sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
+        .orderBy(drizzleOrm.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 = xstate.fromCallback(({ sendBack, input: { context } }) => {
@@ -7056,25 +7622,6 @@ const initialize = xstate.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(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedUid, seedUid), drizzleOrm.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
@@ -7104,7 +7651,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -7480,7 +8027,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -7785,7 +8332,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-Dw0b_Sf8.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-BQokoaRe.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName);
                             if (!schemaFromFile?.validation) {
                                 // Fallback: get validation from schemaData in database (Schema context may not be loaded yet)
@@ -8169,9 +8716,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -8369,7 +8916,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DVQrRpse.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-DCflhpcI.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, propertyRecordSchema.dataType, propertyRecordSchema.validation, propertyRecordSchema.refValueType);
         if (!validationResult.isValid && validationResult.errors.length > 0) {
@@ -8956,7 +9503,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -9971,7 +10518,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')) {
@@ -9988,7 +10537,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-CKJeh6ic.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DTkoTvcq.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -10845,7 +11394,7 @@ class ItemProperty {
     }
     async save() {
         const ctx = this._getSnapshotContext();
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-gfm5thj7.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
         await assertItemOwned({
             seedLocalId: ctx?.seedLocalId ?? undefined,
             seedUid: ctx?.seedUid ?? undefined,
@@ -11082,7 +11631,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;
     }
@@ -11103,6 +11652,7 @@ const updateSeedUid = async ({ seedLocalId, seedUid, publisher, }) => {
         .set({
         uid: seedUid,
         ...(shouldSetPublisher && { publisher }),
+        ...(attestationCreatedAt != null && { attestationCreatedAt }),
         updatedAt: Date.now(),
     })
         .where(drizzleOrm.eq(seeds.localId, seedLocalId));
@@ -11183,7 +11733,7 @@ class Item {
             });
         };
         this.unpublish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-gfm5thj7.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
             const { getRevokeExecutor } = await Promise.resolve().then(function () { return publishConfig; });
             await assertItemOwned(this);
             const seedUid = this.seedUid;
@@ -11207,7 +11757,7 @@ class Item {
             this._service.send({ type: 'updateContext', revokedAt });
         };
         this.publish = async () => {
-            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-gfm5thj7.js'); });
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
             await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
@@ -11241,23 +11791,28 @@ class Item {
                 });
             });
         };
-        this.getPublishUploads = async () => {
+        this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdSwst2x.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DdVy-5fK.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            return await getPublishUploads(this);
+            return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-h_Rz8nVX.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-DP2fm4q8.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;
@@ -11301,7 +11856,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;
@@ -11375,9 +11932,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;
@@ -11433,7 +11989,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)) {
@@ -11531,7 +12098,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;
             }
         }
@@ -11703,7 +12281,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;
     }
     /**
@@ -12138,6 +12727,14 @@ 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 seedSchemaMod = await Promise.resolve().then(function () { return schema$1; });
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -12213,7 +12810,7 @@ class Item {
                     }
                 }
                 // Update context with latest version info
-                this._service.send({
+                sendToItemMachine({
                     type: 'updateContext',
                     latestVersionLocalId: currentVersionLocalId,
                     latestVersionUid: seedRecord.latestVersionUid,
@@ -12268,7 +12865,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,
@@ -12339,7 +12936,7 @@ class Item {
                                                 modelName: itemModelName,
                                             });
                                             if (property) {
-                                                this._service.send({
+                                                sendToItemMachine({
                                                     type: 'addPropertyInstance',
                                                     propertyName,
                                                     propertyInstance: property,
@@ -12358,7 +12955,7 @@ class Item {
                                 }
                             }
                             // Update context with latest version info
-                            this._service.send({
+                            sendToItemMachine({
                                 type: 'updateContext',
                                 latestVersionLocalId,
                                 latestVersionUid: latestVersion.uid || undefined,
@@ -12448,7 +13045,7 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
-        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-gfm5thj7.js'); });
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-DanM_n8E.js'); });
         await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKey = context.seedUid || context.seedLocalId;
@@ -12509,37 +13106,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$h = debug('seedSdk:services:events');
-const handleServiceSaveState = (event) => {
-    const { state, serviceId } = event;
-    logger$h(`[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();
@@ -13110,6 +13676,37 @@ const syncDbWithEasHandler = lodashEs.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$h = debug('seedSdk:services:events');
+const handleServiceSaveState = (event) => {
+    const { state, serviceId } = event;
+    logger$h(`[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);
 };
@@ -13270,6 +13867,7 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
                 dbConfig,
                 schemaFile,
                 schema,
+                syncFromEasOnAddressChange: options.syncFromEasOnAddressChange ?? false,
             } });
         if (arweaveDomain) {
             setArweaveDomain(arweaveDomain);
@@ -16085,8 +16683,64 @@ const processSchemaFiles = xstate.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, } = exports.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 = xstate.setup({
     types: {
         context: {},
@@ -16245,12 +16899,18 @@ const clientManagerMachine = xstate.setup({
             }),
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
-                    actions: xstate.assign(({ event }) => {
-                        const { key, value } = event;
-                        return {
-                            isSaving: false
-                        };
-                    }),
+                    actions: [
+                        xstate.assign(({ event }) => {
+                            return {
+                                isSaving: false,
+                            };
+                        }),
+                        ({ context, event }) => maybeRunSyncFromEasAfterAddressSave({
+                            context,
+                            event: event,
+                        }),
+                        ({ event }) => emitAddressesPersistedIfAddressesKey(event),
+                    ],
                 },
                 [SET_ADDRESSES]: {
                     actions: [
@@ -16289,6 +16949,7 @@ const clientManager = xstate.createActor(clientManagerMachine, {
         isInitialized: false,
         addressesSet: false,
         isSaving: false,
+        syncFromEasOnAddressChange: false,
     }
 });
 const subscription = clientManager.subscribe((snapshot) => {
@@ -16337,6 +16998,7 @@ const clientInstance = {
                     isInitialized: false,
                     addressesSet: false,
                     isSaving: false,
+                    syncFromEasOnAddressChange: false,
                     endpoints: undefined,
                     addresses: undefined,
                     ownedAddresses: undefined,
@@ -16623,7 +17285,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-Cuj839nX.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-sNx_ZQZX.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -16640,7 +17302,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-TFe24NNG.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-B4RRA-0g.js'); })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -18594,7 +19256,7 @@ class Db extends BaseDb {
         // You can inspect what will happen before applying
         await apply();
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-BiXK4hT1.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-DhAXAuSf.js'); });
         await backfillMetadataPropertyIds();
         return this.db;
     }
@@ -19241,7 +19903,7 @@ const getTsImport = async (filePath) => {
 
 // Get the directory of this file to resolve relative paths
 // @ts-ignore - rollup plugin-typescript doesn't recognize import.meta with module: "preserve"
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-pyKmk9hA.js', document.baseURI).href)));
+const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-D1qR8xnb.js', document.baseURI).href)));
 path.dirname(__filename$1);
 const commandExists = (command) => {
     try {
@@ -19714,6 +20376,7 @@ exports.Date = Date$1;
 exports.Db = Db;
 exports.File = File$1;
 exports.FileManager = FileManager;
+exports.Html = Html;
 exports.INIT_SCRIPT_SUCCESS_MESSAGE = INIT_SCRIPT_SUCCESS_MESSAGE;
 exports.INTERNAL_DATA_TYPES = INTERNAL_DATA_TYPES;
 exports.INTERNAL_PROPERTY_NAMES = INTERNAL_PROPERTY_NAMES;
@@ -19734,6 +20397,7 @@ exports.Relation = Relation;
 exports.SCHEMA_TS = SCHEMA_TS;
 exports.SEEDPROTOCOL_Seed_Protocol_v1 = SEEDPROTOCOL_Seed_Protocol_v1;
 exports.SEED_PROTOCOL_SCHEMA_NAME = SEED_PROTOCOL_SCHEMA_NAME;
+exports.THtmlEmbeddedDataUriPolicy = THtmlEmbeddedDataUriPolicy;
 exports.TModelSchema = TModelSchema;
 exports.TModelValues = TModelValues;
 exports.TProperty = TProperty;
@@ -19772,6 +20436,7 @@ exports.getEasSchemaUidForModel = getEasSchemaUidForModel;
 exports.getEasSchemaUidForSchemaDefinition = getEasSchemaUidForSchemaDefinition;
 exports.getGetAdditionalSyncAddresses = getGetAdditionalSyncAddresses;
 exports.getItemData = getItemData;
+exports.getLatestPublishedVersionRow = getLatestPublishedVersionRow;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
 exports.getModelIdByFileId = getModelIdByFileId;
@@ -19780,8 +20445,10 @@ exports.getPropertyData = getPropertyData$1;
 exports.getPropertyIdForModelAndName = getPropertyIdForModelAndName;
 exports.getRefValueType = getRefValueType;
 exports.getTsImport = getTsImport;
+exports.htmlEmbeddedImageCoPublish = htmlEmbeddedImageCoPublish;
 exports.importJsonSchema = importJsonSchema;
 exports.isInternalSchema = isInternalSchema;
+exports.isValidEasAttestationUid = isValidEasAttestationUid;
 exports.listCompleteSchemaFiles = listCompleteSchemaFiles;
 exports.loadAllSchemasFromDb = loadAllSchemasFromDb;
 exports.loadModelsFromDbForSchema = loadModelsFromDbForSchema;
@@ -19816,4 +20483,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-pyKmk9hA.js.map
+//# sourceMappingURL=index-D1qR8xnb.js.map