@seedprotocol/sdk 0.4.17 → 0.4.19

package/dist/{getPublishPayload-CdfPTl8l.js → getPublishPayload-eJL7ktes.js}

@@ -1,8 +1,8 @@
-import { w as getEasSchemaUidForModel, Z as ZERO_BYTES32, o as BaseDb, x as models, y as properties, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, z as versions, A as modelPropertiesToObject, b as ModelPropertyDataTypes, q as getCorrectId, C as parseListPropertyValueFromStorage, E as INTERNAL_PROPERTY_NAMES, G as defaultAttestationData, H as INTERNAL_DATA_TYPES, K as toSnakeCase$1, O as getEasSchemaUidForSchemaDefinition, Q as getEasSchemaForItemProperty } from './index-uPXtq2cf.js';
+import { Z as ZERO_BYTES32, x as getEasSchemaUidForModel, o as BaseDb, y as models, z as properties, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, A as versions, C as modelPropertiesToObject, b as ModelPropertyDataTypes, r as resolveSeedIdsFromRefString, q as normalizeRelationPropertyValue, E as parseListPropertyValueFromStorage, G as getCorrectId, H as INTERNAL_PROPERTY_NAMES, K as defaultAttestationData, O as INTERNAL_DATA_TYPES, Q as toSnakeCase$1, S as getEasSchemaUidForSchemaDefinition, U as getEasSchemaForItemProperty } from './index-BvZCYMxA.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
 import pluralize from 'pluralize';
-import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-CJWdYH9W.js';
-import { getPropertySchema } from './property-Dt0U3UXJ.js';
+import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-B74LN_bz.js';
+import { getPropertySchema } from './property-BOdk-wW1.js';
 import { upperFirst, camelCase } from 'lodash-es';
 import { eq, and, desc } from 'drizzle-orm';
 import debug from 'debug';
@@ -24,6 +24,52 @@ debug('seedSdk:db:getPublishPayload');
 function addValidationError(ctx, message, field, code = 'publish_validation') {
     ctx.errors.push({ field: field ?? '', message, code });
 }
+function isStorageTransactionPropertyName(name) {
+    return name === 'storageTransactionId' || name === 'storage_transaction_id';
+}
+/**
+ * Segmentation or naming variants can leave two rows for the same logical field; keep one
+ * resolved slot so processBasicProperties emits a single storage tx attestation.
+ */
+function replaceStorageTransactionInBasicProperties(itemBasicProperties, resolved) {
+    const filtered = itemBasicProperties.filter((p) => !isStorageTransactionPropertyName(p.propertyName));
+    itemBasicProperties.length = 0;
+    itemBasicProperties.push(...filtered, resolved);
+}
+/** If multiple storageTransactionId ItemProperty rows slipped in, keep one (last wins). */
+function dedupeOneStorageTransactionPropertyInList(itemBasicProperties) {
+    const nonStorage = [];
+    const storage = [];
+    for (const p of itemBasicProperties) {
+        if (isStorageTransactionPropertyName(p.propertyName)) {
+            storage.push(p);
+        }
+        else {
+            nonStorage.push(p);
+        }
+    }
+    if (storage.length <= 1)
+        return;
+    itemBasicProperties.length = 0;
+    itemBasicProperties.push(...nonStorage, storage[storage.length - 1]);
+}
+/**
+ * Two relation/image props (e.g. content + featureImage) can reference the same File/Image seed.
+ * Only one child PublishPayload should exist per related seedLocalId; merge propertiesToUpdate instead.
+ */
+function mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedSeedLocalId, publishLocalId, propertySchemaUid) {
+    const existing = multiPublishPayload.find((p) => p.localId === relatedSeedLocalId);
+    if (!existing)
+        return false;
+    const pts = existing.propertiesToUpdate ?? [];
+    const already = pts.some((e) => e.publishLocalId === publishLocalId &&
+        String(e.propertySchemaUid ?? '').toLowerCase() ===
+            String(propertySchemaUid ?? '').toLowerCase());
+    if (!already) {
+        pts.push({ publishLocalId, propertySchemaUid });
+    }
+    return true;
+}
 const getVersionUid = (item) => {
     const latestVersion = item.latestVersionUid;
     if (latestVersion && typeof latestVersion === 'object' && latestVersion.uid) {
@@ -55,8 +101,8 @@ async function resolveVersionUid(seedLocalId, seedUid) {
             return uid;
     }
     try {
-        const _mod_0 = await import('./index-uPXtq2cf.js');
-        const _ns_0 = _mod_0.br;
+        const _mod_0 = await import('./index-BvZCYMxA.js');
+        const _ns_0 = _mod_0.bB;
         const { getItemVersionsFromEas } = _ns_0;
         const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
         const latest = attestations?.[0];
@@ -80,9 +126,20 @@ const getPropertyData = async (itemProperty, ctx) => {
     }
     let schemaUid = itemProperty.schemaUid;
     const ip = itemProperty;
-    const nameForEas = ip.storagePropertyName && ip.storagePropertyName.length > 0
+    const propertyDefForName = itemProperty.propertyDef;
+    let nameForEas = ip.storagePropertyName && ip.storagePropertyName.length > 0
         ? ip.storagePropertyName
         : itemProperty.propertyName;
+    // Align List-of-relation EAS field name with processListProperty (authorIdentityIds for authors → Identity)
+    if (propertyDefForName?.dataType === ModelPropertyDataTypes.List &&
+        (propertyDefForName.ref || propertyDefForName.refModelName) &&
+        !(ip.storagePropertyName && ip.storagePropertyName.length > 0)) {
+        const ref = propertyDefForName.ref ?? propertyDefForName.refModelName;
+        if (ref) {
+            const singular = pluralize.singular(itemProperty.propertyName);
+            nameForEas = `${singular}${ref}Ids`;
+        }
+    }
     const propertyNameForSchema = toSnakeCase$1(nameForEas);
     const schemaDef = `${easDataType} ${propertyNameForSchema}`;
     if (!schemaUid) {
@@ -116,8 +173,8 @@ const ensurePropertyDefs = async (targetItem) => {
             schema = await getPropertySchema(targetItem.modelName, itemProperty.propertyName);
             if (!schema) {
                 try {
-                    const _mod_1 = await import('./index-uPXtq2cf.js');
-                    const _ns_1 = _mod_1.bv;
+                    const _mod_1 = await import('./index-BvZCYMxA.js');
+                    const _ns_1 = _mod_1.bF;
                     const { Model } = _ns_1;
                     const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
                     let model = Model.getByName(normalizedModelName);
@@ -199,7 +256,8 @@ const getSchemaEncoder = async () => {
     }
     return SchemaEncoderClass;
 };
-const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx) => {
+const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx, buildOpts) => {
+    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
     for (const basicProperty of itemBasicProperties) {
         // Skip SDK-internal properties (e.g. publisher) - never attest to EAS
         if (INTERNAL_PROPERTY_NAMES.includes(basicProperty.propertyName)) {
@@ -211,9 +269,15 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
         const isFileImageHtml = propertyDef?.dataType === ModelPropertyDataTypes.File ||
             propertyDef?.dataType === ModelPropertyDataTypes.Image ||
             propertyDef?.dataType === ModelPropertyDataTypes.Html;
-        // File/Image/Html must use propertyValue (seed ID), not basicProperty.value which returns
-        // renderValue (file content) for File—bytes32 can only hold 31 bytes.
-        let value = isFileImageHtml && context
+        const isJsonStorage = propertyDef?.dataType === ModelPropertyDataTypes.Json ||
+            propertyDef?.refValueType === ModelPropertyDataTypes.Json;
+        const isRelation = propertyDef?.dataType === ModelPropertyDataTypes.Relation;
+        // storageTransactionId is usually Text in the schema; .value still prefers renderValue (URL, label).
+        const isStorageTransactionIdProp = isStorageTransactionPropertyName(basicProperty.propertyName);
+        // File/Image/Html + Relation + Json storage + storage tx id: use propertyValue (canonical).
+        // basicProperty.value prefers renderValue (filename, blob URL, display text)—never use that for publish.
+        const preferPropertyValueForPublish = isFileImageHtml || isRelation || isJsonStorage || isStorageTransactionIdProp;
+        let value = preferPropertyValueForPublish && context
             ? context.propertyValue
             : (basicProperty.value ??
                 (context ? context.propertyValue : undefined));
@@ -221,9 +285,31 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
         if (!context) {
             continue;
         }
-        if (!value || basicProperty.uid) {
+        // Relation + Image/File/Html/Json refs often expose seedLocalId on context.propertyValue while .value is an object — align for encode + resolve hints
+        if (propertyDef?.dataType === ModelPropertyDataTypes.Relation ||
+            isFileImageHtml ||
+            isJsonStorage) {
+            const pv = context.propertyValue;
+            if (typeof value === 'object' || value == null) {
+                if (typeof pv === 'string' && pv.trim())
+                    value = pv.trim();
+                else if (pv && typeof pv === 'object' && typeof pv.seedLocalId === 'string')
+                    value = pv.seedLocalId;
+            }
+        }
+        if (!value) {
             continue;
         }
+        // Patch mode skips properties that already have an EAS uid. storageTransactionId must still
+        // attest after Arweave upload when we have a tx id; metadata uid can be stale or set without a chain attestation.
+        if (basicProperty.uid && !forceFullSnapshot) {
+            const allowStorageTxAttestation = isStorageTransactionIdProp &&
+                typeof value === 'string' &&
+                value.trim() !== '';
+            if (!allowStorageTxAttestation) {
+                continue;
+            }
+        }
         const propertyData = await getPropertyData(basicProperty, ctx);
         if (!propertyData)
             continue;
@@ -255,7 +341,7 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
         }
         // Validate against property validation rules (enum, pattern, minLength, maxLength) before encoding
         if (propertyDef?.validation) {
-            const { SchemaValidationService } = await import('./SchemaValidationService-DXxRk-9Q.js');
+            const { SchemaValidationService } = await import('./SchemaValidationService-DQx83Cte.js');
             const validationService = new SchemaValidationService();
             const validationResult = validationService.validatePropertyValue(value, propertyDef.dataType, propertyDef.validation, propertyDef.refValueType);
             if (!validationResult.isValid && validationResult.errors.length > 0) {
@@ -264,19 +350,42 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
                 continue;
             }
         }
+        /** Raw id per list slot (nanoid local id or 0x… uid) for resolvePublishPayloadValues after sequential publish */
+        let rawListIdsForResolve;
         if (schemaDef.startsWith('bytes32[]')) {
             const newValues = [];
+            const rawIds = [];
             const iterableValue = Array.isArray(value) ? value
                 : value != null && typeof value[Symbol.iterator] === 'function' ? value
                     : [];
             for (const seedId of iterableValue) {
-                if (seedId.length !== 66 && !seedId.startsWith('0x')) {
-                    newValues.push(ethers.encodeBytes32String(seedId));
+                const idStr = typeof seedId === 'string'
+                    ? seedId
+                    : seedId &&
+                        typeof seedId === 'object' &&
+                        (seedId.seedLocalId ?? seedId.seedUid ?? seedId.localId ?? seedId.uid)
+                        ? String(seedId.seedLocalId ??
+                            seedId.seedUid ??
+                            '')
+                        : '';
+                if (!idStr)
+                    continue;
+                const trimmed = idStr.trim();
+                if (!trimmed)
                     continue;
+                rawIds.push(trimmed);
+                if (trimmed.length !== 66 && !trimmed.startsWith('0x')) {
+                    newValues.push(ethers.encodeBytes32String(trimmed));
+                }
+                else {
+                    newValues.push(trimmed);
                 }
-                newValues.push(seedId);
             }
             value = newValues;
+            const needsUidResolve = rawIds.some((id) => id.length !== 66 || !id.startsWith('0x'));
+            if (needsUidResolve && rawIds.length > 0) {
+                rawListIdsForResolve = rawIds;
+            }
         }
         // uint256 (Date) must be numeric/BigInt; normalize ISO strings to Unix seconds
         if (easDataType === 'uint256' && (typeof value === 'string' || value instanceof Date)) {
@@ -301,7 +410,7 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
             continue;
         }
         // For storageTransactionId, set refUID to versionUid so it references the Version attestation (contract may use when supported)
-        const refUid = basicProperty.propertyName === 'storageTransactionId'
+        const refUid = isStorageTransactionIdProp
             ? itemPublishData.versionUid
             : defaultAttestationData.refUID;
         const attestationEntry = {
@@ -315,19 +424,31 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx)
             ],
         };
         // For relation/image properties with seedLocalId, store resolution hints for resolvePublishPayloadValues
-        if (typeof value === 'string' &&
-            value.length === 10 &&
+        const looksLikeLocalSeedRef = typeof value === 'string' &&
+            !value.startsWith('0x') &&
+            value.length !== 66 &&
+            /^[a-zA-Z0-9_-]{10,21}$/.test(value.trim());
+        if (looksLikeLocalSeedRef &&
             (easDataType === 'bytes32' || easDataType === 'string')) {
             attestationEntry._propertyName = basicProperty.propertyName;
+            attestationEntry._propertyNameForSchema = propertyNameForSchema;
             attestationEntry._schemaDef = schemaDef;
-            attestationEntry._unresolvedValue = value;
+            attestationEntry._unresolvedValue = value.trim();
             attestationEntry._easDataType = easDataType;
         }
+        if (rawListIdsForResolve && rawListIdsForResolve.length > 0) {
+            attestationEntry._propertyName = basicProperty.propertyName;
+            attestationEntry._propertyNameForSchema = propertyNameForSchema;
+            attestationEntry._schemaDef = schemaDef;
+            attestationEntry._easDataType = 'bytes32[]';
+            attestationEntry._rawListIdsForResolve = rawListIdsForResolve;
+        }
         itemPublishData.listOfAttestations.push(attestationEntry);
     }
     return itemPublishData;
 };
-const processRelationOrImageProperty = async (relationOrImageProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx) => {
+const processRelationOrImageProperty = async (relationOrImageProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx, buildOpts) => {
+    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
     let relationOrImageSchemaUid = relationOrImageProperty.schemaUid;
     if (!relationOrImageSchemaUid && relationOrImageProperty.propertyDef) {
         const propertyData = await getPropertyData(relationOrImageProperty, ctx);
@@ -356,9 +477,9 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
                 relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Image ||
                 relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Html ||
                 relationOrImageProperty.propertyDef?.refValueType === ModelPropertyDataTypes.Json));
-    if (!value && isStorageSeed && (context.seedLocalId || context.seedUid)) {
-        const _mod_2 = await import('./index-uPXtq2cf.js');
-        const _ns_2 = _mod_2.bs;
+    if (isStorageSeed && (context.seedLocalId || context.seedUid)) {
+        const _mod_2 = await import('./index-BvZCYMxA.js');
+        const _ns_2 = _mod_2.bC;
         const { getPropertyData: getPropertyDataFromDb } = _ns_2;
         const metaRow = await getPropertyDataFromDb({
             propertyName: relationOrImageProperty.propertyName,
@@ -366,8 +487,15 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
             seedUid: context.seedUid,
         });
         const fromMeta = metaRow?.propertyValue;
-        if (fromMeta && typeof fromMeta === 'string' && fromMeta.trim() !== '') {
-            value = fromMeta;
+        if (typeof fromMeta === 'string' && fromMeta.trim() !== '') {
+            const idsCtx = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(value) ?? '');
+            const idsDb = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(fromMeta) ?? '');
+            if (!value) {
+                value = fromMeta;
+            }
+            else if (!idsCtx.seedLocalId && !idsCtx.seedUid && (idsDb.seedLocalId || idsDb.seedUid)) {
+                value = fromMeta;
+            }
         }
     }
     const propertyDef = relationOrImageProperty.propertyDef;
@@ -421,11 +549,15 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
             `A value pointing to a valid ${refLabel} item is required to publish.`, relationOrImageProperty.propertyName);
         return multiPublishPayload;
     }
-    if (!value || relationOrImageProperty.uid) {
+    if (!value) {
+        return multiPublishPayload;
+    }
+    if (relationOrImageProperty.uid && !forceFullSnapshot) {
         return multiPublishPayload;
     }
-    const { localId: seedLocalId, uid: seedUid } = getCorrectId(value);
-    // Value is not a valid seed reference (10-char localId or 66-char uid)
+    const normalizedRef = normalizeRelationPropertyValue(value);
+    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalizedRef ?? '');
+    // Value is not a valid seed reference (local id or 0x uid)
     if (!seedLocalId && !seedUid) {
         if (isRequired) {
             addValidationError(ctx, `Required relation ${relationOrImageProperty.propertyName} has invalid value: ${JSON.stringify(value)}. ` +
@@ -434,7 +566,7 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         return multiPublishPayload;
     }
     // Use dynamic import to break circular dependency
-    const getItemMod = await import('./getItem-ClK0UZqi.js');
+    const getItemMod = await import('./getItem-Bd9U9Yih.js');
     const { getItem } = getItemMod;
     const relatedItem = await getItem({
         seedLocalId,
@@ -450,7 +582,7 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         return multiPublishPayload;
     }
     // When Image/Relation already has seedUid (published), skip creating its payload—only add the property to parent
-    if (relatedItem.seedUid) {
+    if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
         return multiPublishPayload;
     }
     const versionUid = getVersionUid(relatedItem);
@@ -477,6 +609,9 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         addValidationError(ctx, `Schema UID not found for model: ${modelName}`, relationOrImageProperty.propertyName);
         return multiPublishPayload;
     }
+    if (mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedItem.seedLocalId, originalSeedLocalId, relationOrImageSchemaUid)) {
+        return multiPublishPayload;
+    }
     let publishPayload = {
         localId: relatedItem.seedLocalId,
         seedIsRevocable: true,
@@ -494,21 +629,40 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
     };
     await ensurePropertyDefs(relatedItem);
     const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties(relatedItem);
-    if (itemUploadProperties.length === 1) {
-        const uploadProperty = itemUploadProperties[0];
-        const itemProperty = uploadProperty.itemProperty;
-        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === relatedItem.seedLocalId);
+    const relatedStorageUpload = resolveStorageTransactionUploadSlot(relatedItem, itemUploadProperties);
+    if (relatedStorageUpload) {
+        const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, relatedItem.seedLocalId);
         if (transactionData) {
-            itemProperty.value = transactionData.txId;
-            await itemProperty.save();
-            itemBasicProperties.push(itemProperty);
+            const itemProperty = relatedStorageUpload.itemProperty;
+            // Publish encoding reads context.propertyValue; do not await ItemProperty.save() here — it
+            // uses xstate waitFor(10s) for idle and can time out while the machine is busy or still loading.
+            itemProperty.getService().send({
+                type: 'updateContext',
+                propertyValue: transactionData.txId,
+                renderValue: transactionData.txId,
+            });
+            replaceStorageTransactionInBasicProperties(itemBasicProperties, itemProperty);
         }
     }
-    publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx);
+    for (const p of itemBasicProperties) {
+        if (isStorageTransactionPropertyName(p.propertyName) &&
+            !p.propertyDef &&
+            relatedItem.modelName) {
+            const schema = await getPropertySchema(relatedItem.modelName, 'storageTransactionId');
+            if (schema) {
+                p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
+            }
+        }
+    }
+    dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
+    publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx, {
+        forceFullSnapshot,
+    });
     multiPublishPayload.push(publishPayload);
     return multiPublishPayload;
 };
-const processListProperty = async (listProperty, multiPublishPayload, originalSeedLocalId, ctx) => {
+const processListProperty = async (listProperty, multiPublishPayload, originalSeedLocalId, ctx, buildOpts) => {
+    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
     // processListProperty only handles list-of-relations; list-of-primitives go to itemBasicProperties
     if (!listProperty.propertyDef?.ref) {
         addValidationError(ctx, `processListProperty requires ref (list of relations). List property "${listProperty.propertyName}" has no ref. List-of-primitives should be in itemBasicProperties.`, listProperty.propertyName);
@@ -531,7 +685,10 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         return multiPublishPayload;
     }
     let value = context.propertyValue;
-    if (!value || listProperty.uid) {
+    if (!value) {
+        return multiPublishPayload;
+    }
+    if (listProperty.uid && !forceFullSnapshot) {
         return multiPublishPayload;
     }
     const singularPropertyName = pluralize.singular(listProperty.propertyName);
@@ -556,7 +713,7 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         if (!seedLocalId && !seedUid)
             continue;
         // Use dynamic import to break circular dependency
-        const getItemMod = await import('./getItem-ClK0UZqi.js');
+        const getItemMod = await import('./getItem-Bd9U9Yih.js');
         const { getItem } = getItemMod;
         const relatedItem = await getItem({
             seedLocalId,
@@ -566,7 +723,7 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
             console.error(`No related item found for list property: ${listProperty.propertyName}`);
             continue;
         }
-        if (relatedItem.seedUid) {
+        if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
             continue;
         }
         const versionUid = getVersionUid(relatedItem);
@@ -593,6 +750,9 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
             addValidationError(ctx, `Schema UID not found for model: ${modelName}`, listProperty.propertyName);
             continue;
         }
+        if (mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedItem.seedLocalId, originalSeedLocalId, listPropertySchemaUid)) {
+            continue;
+        }
         let publishPayload = {
             localId: relatedItem.seedLocalId,
             seedIsRevocable: true,
@@ -610,11 +770,141 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         };
         await ensurePropertyDefs(relatedItem);
         const { itemBasicProperties } = await getSegmentedItemProperties(relatedItem);
-        publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx);
+        dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
+        publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx, {
+            forceFullSnapshot,
+        });
         multiPublishPayload.push(publishPayload);
     }
     return multiPublishPayload;
 };
+/**
+ * Same EAS schema + same encoded attestation bytes (data field). Intentionally ignores refUID so
+ * duplicate storageTransactionId rows that only differ by ref (e.g. 0x0 vs version uid) collapse.
+ */
+function attestationPayloadDedupeKey(att) {
+    const schema = String(att.schema ?? '').toLowerCase();
+    const dataArr = att.data;
+    const d0 = Array.isArray(dataArr) ? dataArr[0] : undefined;
+    const dataHex = d0 && typeof d0 === 'object' && d0 !== null && 'data' in d0
+        ? String(d0.data ?? '').toLowerCase()
+        : '';
+    return `${schema}:${dataHex}`;
+}
+/**
+ * Collapse duplicate rows in listOfAttestations (same schema + encoded payload).
+ */
+function dedupeListOfAttestationsInEachPayload(payload) {
+    for (const p of payload) {
+        const list = p.listOfAttestations ?? [];
+        if (list.length <= 1)
+            continue;
+        const seen = new Set();
+        const out = [];
+        for (const a of list) {
+            const k = attestationPayloadDedupeKey(a);
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            out.push(a);
+        }
+        p.listOfAttestations = out;
+    }
+    return payload;
+}
+/**
+ * Merge duplicate PublishPayload rows with the same localId (ordering / batch edge cases).
+ * Dedupe listOfAttestations so identical storage tx attestations are not emitted twice.
+ */
+function dedupeMultiPublishPayloadByLocalId(payload) {
+    const map = new Map();
+    const order = [];
+    for (const p of payload) {
+        const id = p.localId;
+        const existing = map.get(id);
+        if (!existing) {
+            map.set(id, p);
+            order.push(id);
+            continue;
+        }
+        const ptu = [...(existing.propertiesToUpdate ?? [])];
+        for (const u of p.propertiesToUpdate ?? []) {
+            if (!ptu.some((e) => e.publishLocalId === u.publishLocalId &&
+                String(e.propertySchemaUid ?? '').toLowerCase() ===
+                    String(u.propertySchemaUid ?? '').toLowerCase())) {
+                ptu.push(u);
+            }
+        }
+        existing.propertiesToUpdate = ptu;
+        const seenKeys = new Set((existing.listOfAttestations ?? []).map((a) => attestationPayloadDedupeKey(a)));
+        const merged = [...(existing.listOfAttestations ?? [])];
+        for (const a of p.listOfAttestations ?? []) {
+            const k = attestationPayloadDedupeKey(a);
+            if (seenKeys.has(k))
+                continue;
+            seenKeys.add(k);
+            merged.push(a);
+        }
+        existing.listOfAttestations = merged;
+    }
+    return order.map((id) => map.get(id)).filter(Boolean);
+}
+/**
+ * Child File/Image items may keep storageTransactionId only on the item machine's
+ * propertyInstances map; allProperties / item.properties can omit it during publish.
+ */
+function getStorageTransactionPropertyFromItemInstances(item) {
+    try {
+        const svc = item.getService?.();
+        if (!svc)
+            return undefined;
+        const snap = svc.getSnapshot();
+        const instances = snap.context?.propertyInstances;
+        if (!instances || !(instances instanceof Map))
+            return undefined;
+        const direct = instances.get('storageTransactionId') ?? instances.get('storage_transaction_id');
+        if (direct)
+            return direct;
+        for (const [, p] of instances) {
+            if (p && isStorageTransactionPropertyName(p.propertyName))
+                return p;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Resolve storageTransactionId (+ ItemStorage children) for publish.
+ * getSegmentedItemProperties can yield empty itemUploadProperties when the child Item never
+ * hydrated storageTransactionId into the upload bucket (e.g. only uri/metadata rows), while
+ * getStorageSeedUploads still creates an Arweave upload keyed by child seedLocalId.
+ */
+function resolveStorageTransactionUploadSlot(item, itemUploadProperties) {
+    const named = itemUploadProperties.find((u) => isStorageTransactionPropertyName(u.itemProperty.propertyName));
+    if (named)
+        return named;
+    if (itemUploadProperties.length === 1)
+        return itemUploadProperties[0];
+    const all = item.allProperties;
+    const fromInstances = getStorageTransactionPropertyFromItemInstances(item);
+    const storagePropEarly = all?.['storageTransactionId'] ??
+        all?.['storage_transaction_id'] ??
+        Object.values(all ?? {}).find((p) => !!p && isStorageTransactionPropertyName(p.propertyName)) ??
+        item.properties?.find((p) => isStorageTransactionPropertyName(p.propertyName));
+    const storageProp = storagePropEarly ?? fromInstances;
+    if (!storageProp)
+        return undefined;
+    const childProps = item.properties?.filter((p) => p.propertyDef &&
+        p.propertyDef.storageType === 'ItemStorage') ?? [];
+    return { itemProperty: storageProp, childProperties: childProps };
+}
+function findUploadedTxForSeedLocalId(uploadedTransactions, seedLocalId) {
+    const t = seedLocalId.trim();
+    return (uploadedTransactions.find((u) => u.seedLocalId === t) ??
+        uploadedTransactions.find((u) => u.seedLocalId != null && u.seedLocalId.trim() === t));
+}
 /** Error thrown when publish validation fails. Includes all validation errors for user to fix. */
 class PublishValidationFailedError extends Error {
     constructor(message, validationErrors) {
@@ -623,8 +913,13 @@ class PublishValidationFailedError extends Error {
         this.name = 'PublishValidationFailedError';
     }
 }
-const getPublishPayload = async (item, uploadedTransactions) => {
+const getPublishPayload = async (item, uploadedTransactions, options) => {
     const validationCtx = { errors: [] };
+    const publishMode = options?.publishMode ?? 'patch';
+    const forceFullSnapshot = publishMode === 'new_version';
+    if (publishMode === 'new_version' && (!item.seedUid || item.seedUid === ZERO_BYTES32)) {
+        addValidationError(validationCtx, 'Publishing as a new version requires the item to already have a published Seed attestation (seed UID).', 'seedUid', 'publish_new_version_requires_seed');
+    }
     let multiPublishPayload = [];
     // Each PublishPayload is generated from a Seed that needs publishing
     // First we need to determine all Seeds to publish
@@ -645,6 +940,9 @@ const getPublishPayload = async (item, uploadedTransactions) => {
     if (versionUid === ZERO_BYTES32 && item.seedUid && item.seedUid !== ZERO_BYTES32) {
         versionUid = await resolveVersionUid(item.seedLocalId, item.seedUid);
     }
+    if (forceFullSnapshot && item.seedUid && item.seedUid !== ZERO_BYTES32) {
+        versionUid = ZERO_BYTES32;
+    }
     let itemPublishData = {
         localId: item.seedLocalId,
         seedUid: item.seedUid || ZERO_BYTES32,
@@ -691,33 +989,55 @@ const getPublishPayload = async (item, uploadedTransactions) => {
                 `A value pointing to a valid ${refModel} item is required to publish.`, relProp.propertyName);
         }
     }
-    if (itemUploadProperties.length === 1) {
-        const uploadProperty = itemUploadProperties[0];
-        const itemProperty = uploadProperty.itemProperty;
-        const transactionData = uploadedTransactions.find((transaction) => transaction.seedLocalId === item.seedLocalId);
+    const rootStorageUpload = resolveStorageTransactionUploadSlot(item, itemUploadProperties);
+    if (rootStorageUpload) {
+        const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, item.seedLocalId);
         if (transactionData) {
-            itemProperty.value = transactionData.txId;
-            await itemProperty.save();
-            itemBasicProperties.push(itemProperty);
+            const itemProperty = rootStorageUpload.itemProperty;
+            itemProperty.getService().send({
+                type: 'updateContext',
+                propertyValue: transactionData.txId,
+                renderValue: transactionData.txId,
+            });
+            replaceStorageTransactionInBasicProperties(itemBasicProperties, itemProperty);
         }
     }
     for (const relationProperty of relationAndImageProperties) {
-        multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx);
+        multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx, { forceFullSnapshot });
         itemBasicProperties.push(relationProperty);
     }
     for (const listProperty of itemListProperties) {
-        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, item.seedLocalId, validationCtx);
+        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, item.seedLocalId, validationCtx, { forceFullSnapshot });
         itemBasicProperties.push(listProperty);
     }
-    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData, validationCtx);
+    for (const p of itemBasicProperties) {
+        if (isStorageTransactionPropertyName(p.propertyName) && !p.propertyDef && item.modelName) {
+            const schema = await getPropertySchema(item.modelName, 'storageTransactionId');
+            if (schema) {
+                p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
+            }
+        }
+    }
+    dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
+    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData, validationCtx, { forceFullSnapshot });
     multiPublishPayload.push(itemPublishData);
     // Ensure requests are ordered so that when A has propertiesToUpdate pointing to B (publishLocalId),
     // A (the updater) is published before B (the updatee). The contract injects A's seedUid into B's
     // attestation before B is sent to EAS.
+    multiPublishPayload = dedupeMultiPublishPayloadByLocalId(multiPublishPayload);
     multiPublishPayload = orderPayloadByDependencies(multiPublishPayload);
     // Ensure attestations referenced in propertiesToUpdate have at least one data element.
     // The contract writes the seed UID into data[0].data; empty data causes Panic 50.
     multiPublishPayload = ensurePropertiesToUpdateAttestationsHaveData(multiPublishPayload);
+    multiPublishPayload = dedupeListOfAttestationsInEachPayload(multiPublishPayload);
+    if (publishMode === 'new_version') {
+        const rootPayload = multiPublishPayload.find((p) => p.localId === item.seedLocalId);
+        const listLen = rootPayload?.listOfAttestations?.length ?? 0;
+        if (!rootPayload || listLen === 0) {
+            addValidationError(validationCtx, 'Publishing as a new version requires at least one property attestation for the item. ' +
+                'Ensure required fields have values and that publishable properties are present.', 'listOfAttestations', 'publish_new_version_empty_snapshot');
+        }
+    }
     if (validationCtx.errors.length > 0) {
         const combinedMessage = validationCtx.errors.map((e) => e.message).join('\n');
         throw new PublishValidationFailedError(`Validation failed (${validationCtx.errors.length} error${validationCtx.errors.length === 1 ? '' : 's'}):\n${combinedMessage}`, validationCtx.errors);
@@ -729,9 +1049,9 @@ const getPublishPayload = async (item, uploadedTransactions) => {
  * Use in the checking step to fail fast before creating transactions.
  * Pass empty array for uploadedTransactions when validating before Arweave upload.
  */
-const validateItemForPublish = async (item, uploadedTransactions = []) => {
+const validateItemForPublish = async (item, uploadedTransactions = [], options) => {
     try {
-        await getPublishPayload(item, uploadedTransactions);
+        await getPublishPayload(item, uploadedTransactions, options);
         return { isValid: true, errors: [] };
     }
     catch (err) {
@@ -786,37 +1106,110 @@ function ensurePropertiesToUpdateAttestationsHaveData(payload) {
     return payload;
 }
 /**
- * Topological sort: when request A has propertiesToUpdate with publishLocalId B,
- * A (the updater) must appear before B (the updatee). The contract injects A's seedUid
- * into B's attestation before B is sent to EAS; if B is processed first, B's attestation
- * goes out with wrong data (string instead of bytes32).
+ * LocalIds in this batch referenced by attestations (bytes32 / bytes32[]) that must publish before this request.
+ */
+function collectAttestationLocalRefIds(req, allLocalIds) {
+    const refs = [];
+    for (const a of req.listOfAttestations ?? []) {
+        const att = a;
+        if (att._unresolvedValue && allLocalIds.has(att._unresolvedValue)) {
+            refs.push(att._unresolvedValue);
+        }
+        if (Array.isArray(att._rawListIdsForResolve)) {
+            for (const id of att._rawListIdsForResolve) {
+                const t = id != null ? String(id).trim() : '';
+                if (t && allLocalIds.has(t))
+                    refs.push(t);
+            }
+        }
+    }
+    return refs;
+}
+/**
+ * Topological sort (Kahn): edge `from → to` means `from` must publish before `to`.
+ * - propertiesToUpdate: updater before updatee (contract injection).
+ * - _unresolvedValue / _rawListIdsForResolve: referenced seed before request that encodes the ref.
+ * The previous DFS visit could order [Post, Image] when Post appeared first in the input array,
+ * so resolvedUids was empty when Post was published and attestations kept local ids.
  */
 function orderPayloadByDependencies(payload) {
+    if (payload.length <= 1)
+        return payload;
     const byLocalId = new Map();
-    for (const p of payload) {
+    const allIds = new Set();
+    const indexOrder = new Map();
+    for (let i = 0; i < payload.length; i++) {
+        const p = payload[i];
         byLocalId.set(p.localId, p);
+        allIds.add(p.localId);
+        indexOrder.set(p.localId, i);
     }
-    const visited = new Set();
-    const result = [];
-    const visit = (localId) => {
-        if (visited.has(localId))
+    const indegree = new Map();
+    for (const id of allIds)
+        indegree.set(id, 0);
+    const adj = new Map();
+    const addEdge = (from, to) => {
+        if (from === to || !allIds.has(from) || !allIds.has(to))
             return;
-        visited.add(localId);
-        const p = byLocalId.get(localId);
-        if (!p)
+        if (!adj.has(from))
+            adj.set(from, new Set());
+        const set = adj.get(from);
+        if (set.has(to))
             return;
-        result.push(p);
+        set.add(to);
+        indegree.set(to, (indegree.get(to) ?? 0) + 1);
+    };
+    for (const p of payload) {
         for (const u of p.propertiesToUpdate ?? []) {
             const targetId = u.publishLocalId;
-            if (targetId && targetId !== localId)
-                visit(targetId);
+            if (targetId && targetId !== p.localId)
+                addEdge(p.localId, targetId);
+        }
+        for (const refId of collectAttestationLocalRefIds(p, allIds)) {
+            addEdge(refId, p.localId);
+        }
+    }
+    const zero = [];
+    for (const id of allIds) {
+        if ((indegree.get(id) ?? 0) === 0)
+            zero.push(id);
+    }
+    zero.sort((a, b) => (indexOrder.get(a) ?? 0) - (indexOrder.get(b) ?? 0));
+    const result = [];
+    const queue = zero;
+    while (queue.length > 0) {
+        const id = queue.shift();
+        const p = byLocalId.get(id);
+        if (p)
+            result.push(p);
+        for (const to of adj.get(id) ?? []) {
+            const next = (indegree.get(to) ?? 0) - 1;
+            indegree.set(to, next);
+            if (next === 0) {
+                queue.push(to);
+                queue.sort((a, b) => (indexOrder.get(a) ?? 0) - (indexOrder.get(b) ?? 0));
+            }
+        }
+    }
+    if (result.length !== payload.length) {
+        const seen = new Set(result.map((r) => r.localId));
+        for (const p of payload) {
+            if (!seen.has(p.localId))
+                result.push(p);
         }
-    };
-    for (const p of payload) {
-        visit(p.localId);
     }
     return result;
 }
+/** Normalize attestation UID to 32-byte hex for SchemaEncoder bytes32 fields. */
+function padUidForBytes32Schema(uid) {
+    const t = uid.trim();
+    if (!t.startsWith('0x'))
+        return uid;
+    const hex = t.slice(2).replace(/[^0-9a-fA-F]/g, '');
+    if (hex.length === 0)
+        return uid;
+    return ('0x' + hex.padStart(64, '0').slice(-64)).toLowerCase();
+}
 /**
  * Resolves relation/image property values (seedLocalId) to attestation uids after dependent seeds are published.
  * Call after each payload is published, passing the returned attestation uid for that seed's localId.
@@ -832,15 +1225,70 @@ const resolvePublishPayloadValues = async (multiPayload, resolvedUids) => {
         const updatedAttestations = [];
         for (const attestation of payload.listOfAttestations) {
             const entry = attestation;
+            const rawList = entry._rawListIdsForResolve;
+            if (rawList &&
+                rawList.length > 0 &&
+                entry._schemaDef &&
+                (entry._propertyNameForSchema || entry._propertyName)) {
+                const fieldName = entry._propertyNameForSchema ?? toSnakeCase$1(entry._propertyName);
+                const resolvedValues = [];
+                let allSlotsResolved = true;
+                for (const id of rawList) {
+                    const trimmed = id.trim();
+                    if (trimmed.length === 66 && trimmed.startsWith('0x')) {
+                        resolvedValues.push(padUidForBytes32Schema(trimmed));
+                        continue;
+                    }
+                    const r = resolvedUids[trimmed];
+                    if (r) {
+                        resolvedValues.push(padUidForBytes32Schema(r));
+                        continue;
+                    }
+                    allSlotsResolved = false;
+                    break;
+                }
+                // Do not encode or clear hints until every slot has a real uid — otherwise sequential
+                // publish burns encodeBytes32String(localId) into data and drops _rawListIdsForResolve.
+                if (!allSlotsResolved) {
+                    updatedAttestations.push({
+                        ...entry,
+                        data: Array.isArray(entry.data) ? entry.data : [entry.data],
+                    });
+                    continue;
+                }
+                const dataEncoder = new SchemaEncoder(entry._schemaDef);
+                const encodedData = dataEncoder.encodeData([
+                    {
+                        name: fieldName,
+                        type: 'bytes32[]',
+                        value: resolvedValues,
+                    },
+                ]);
+                const baseData = Array.isArray(entry.data) ? entry.data[0] : entry.data;
+                updatedAttestations.push({
+                    ...entry,
+                    data: [
+                        {
+                            ...baseData,
+                            data: encodedData,
+                        },
+                    ],
+                    _rawListIdsForResolve: undefined,
+                    _easDataType: undefined,
+                });
+                continue;
+            }
             const resolvedUid = entry._unresolvedValue && resolvedUids[entry._unresolvedValue];
-            if (resolvedUid && entry._schemaDef && entry._propertyName) {
-                const propertyNameForSchema = toSnakeCase$1(entry._propertyName);
+            const easType = entry._easDataType || 'bytes32';
+            if (resolvedUid && entry._schemaDef && (entry._propertyNameForSchema || entry._propertyName)) {
+                const fieldName = entry._propertyNameForSchema ?? toSnakeCase$1(entry._propertyName);
+                const valueForEncode = easType === 'bytes32' ? padUidForBytes32Schema(resolvedUid) : resolvedUid;
                 const dataEncoder = new SchemaEncoder(entry._schemaDef);
                 const encodedData = dataEncoder.encodeData([
                     {
-                        name: propertyNameForSchema,
-                        type: entry._easDataType || 'bytes32',
-                        value: resolvedUid,
+                        name: fieldName,
+                        type: easType,
+                        value: valueForEncode,
                     },
                 ]);
                 const baseData = Array.isArray(entry.data) ? entry.data[0] : entry.data;
@@ -872,4 +1320,4 @@ const resolvePublishPayloadValues = async (multiPayload, resolvedUids) => {
 };
 
 export { PublishValidationFailedError, getPublishPayload, resolvePublishPayloadValues, validateItemForPublish };
-//# sourceMappingURL=getPublishPayload-CdfPTl8l.js.map
+//# sourceMappingURL=getPublishPayload-eJL7ktes.js.map