@seedprotocol/sdk 0.7.0 → 0.7.1

package/dist/cjs/{getPublishPayload-D5-dYtNq.js → getPublishPayload-CEP_e-Kv.js}

@@ -1,22 +1,22 @@
 'use strict';
 
-var main_cjs = require('./index-C66AfYDG.js');
+var main_cjs = require('./index-Cvvt0-5B.js');
 var easSdk = require('@ethereum-attestation-service/eas-sdk');
 var casing = require('drizzle-orm/casing');
 var eas = require('@seedprotocol/eas');
-var drizzleOrm = require('drizzle-orm');
-var getSegmentedItemProperties = require('./getSegmentedItemProperties-giHO7R3d.js');
-var property = require('./property-BVJIP7SX.js');
+var publishDraftGraph = require('./publishDraftGraph-C38gf302.js');
+var property = require('./property-DbEPQ1m9.js');
 var lodashEs = require('lodash-es');
+var drizzleOrm = require('drizzle-orm');
 var debug = require('debug');
 require('@noble/hashes/sha3');
 require('@noble/hashes/utils');
 require('reflect-metadata');
-require('pluralize');
 require('immer');
 require('xstate');
 require('drizzle-orm/sqlite-core');
 require('@seedprotocol/arweave');
+require('pluralize');
 require('@sinclair/typebox');
 require('nanoid');
 require('nanoid-dictionary');
@@ -35,25 +35,6 @@ require('child_process');
 require('@seedprotocol/arweave/node');
 require('@seedprotocol/eas/node');
 
-/**
- * True when the item's seed attestation was revoked (`seeds.revoked_at` set, by unpublish or EAS
- * sync). Such a seed can't take new versions: publishing again creates a new seed attestation
- * (see "Republishing" in docs/ATTESTATION_REVOCATION.md).
- */
-const isSeedRevoked = async (seedLocalId) => {
-    if (!seedLocalId)
-        return false;
-    const appDb = main_cjs.BaseDb.getAppDb();
-    if (!appDb)
-        return false;
-    const [row] = await appDb
-        .select({ revokedAt: main_cjs.seeds.revokedAt })
-        .from(main_cjs.seeds)
-        .where(drizzleOrm.eq(main_cjs.seeds.localId, seedLocalId))
-        .limit(1);
-    return main_cjs.isVersionRevoked(row?.revokedAt);
-};
-
 /** UTF-8 string to 0x-prefixed bytes32 hex (right-padded with zeros). */
 function encodeBytes32String(value) {
     const bytes = new TextEncoder().encode(value);
@@ -106,91 +87,24 @@ class RelatedItemUnpublishedError extends PublishValidationFailedError {
     }
 }
 
-const selectSeed = {
-    seedLocalId: main_cjs.seeds.localId,
-    seedUid: main_cjs.seeds.uid,
-    revokedAt: main_cjs.seeds.revokedAt,
-    type: main_cjs.seeds.type,
-};
-/**
- * The local seed row a relation/list/image ref points at, by local id or uid. A uid that is no
- * seed's current uid can be the old uid of a seed that was unpublished and published again (a new
- * seed attestation, same local seed): its old version rows still record it, so it resolves to that
- * seed. Null when nothing local matches (e.g. a published uid with no local copy).
- */
-const findRelatedSeedRow = async ({ seedLocalId, seedUid, }) => {
-    const appDb = main_cjs.BaseDb.getAppDb();
-    if (!appDb)
-        return null;
-    if (seedLocalId) {
-        const [row] = await appDb.select(selectSeed).from(main_cjs.seeds).where(drizzleOrm.eq(main_cjs.seeds.localId, seedLocalId)).limit(1);
-        if (row?.seedLocalId)
-            return row;
-    }
-    if (!seedUid || seedUid === main_cjs.ZERO_BYTES32)
-        return null;
-    const [byUid] = await appDb.select(selectSeed).from(main_cjs.seeds).where(drizzleOrm.eq(main_cjs.seeds.uid, seedUid)).limit(1);
-    if (byUid?.seedLocalId)
-        return byUid;
-    const [version] = await appDb
-        .select({ seedLocalId: main_cjs.versions.seedLocalId })
-        .from(main_cjs.versions)
-        .where(drizzleOrm.and(drizzleOrm.eq(main_cjs.versions.seedUid, seedUid), drizzleOrm.isNotNull(main_cjs.versions.seedLocalId)))
-        .limit(1);
-    if (!version?.seedLocalId)
-        return null;
-    const [republished] = await appDb
-        .select(selectSeed)
-        .from(main_cjs.seeds)
-        .where(drizzleOrm.eq(main_cjs.seeds.localId, version.seedLocalId))
-        .limit(1);
-    return republished?.seedLocalId ? republished : null;
-};
-/** The seed is attested and its attestation is live. */
-const isLivePublishedSeed = (row) => !!row?.seedUid && row.seedUid !== main_cjs.ZERO_BYTES32 && !main_cjs.isVersionRevoked(row.revokedAt);
-/** The seed was attested and that attestation was revoked (unpublished). */
-const isUnpublishedSeed = (row) => !!row?.seedUid && row.seedUid !== main_cjs.ZERO_BYTES32 && main_cjs.isVersionRevoked(row.revokedAt);
-/** Model a relation/list/image property points at, from its definition. */
-function relatedModelNameFromDef(propertyDef) {
-    const def = propertyDef;
-    if (!def)
-        return undefined;
-    const dataType = main_cjs.normalizeDataType(def.dataType);
-    if (dataType === main_cjs.ModelPropertyDataTypes.Image)
-        return 'Image';
-    if (dataType === main_cjs.ModelPropertyDataTypes.File)
-        return 'File';
-    if (dataType === main_cjs.ModelPropertyDataTypes.Html)
-        return 'Html';
-    return def.ref ?? def.refModelName;
-}
-/**
- * Name of the item's Html property whose value is the Html seed `htmlSeedLocalId`: the property
- * that refers to the images embedded in that Html (htmlEmbeddedImageCoPublish rows).
- */
-function htmlPropertyNameForHtmlSeed(item, htmlSeedLocalId) {
-    const want = htmlSeedLocalId.trim();
-    for (const p of item.properties ?? []) {
-        if (main_cjs.normalizeDataType(p.propertyDef?.dataType) !== main_cjs.ModelPropertyDataTypes.Html)
-            continue;
-        const snap = p.getService().getSnapshot();
-        const value = 'context' in snap ? snap.context.propertyValue : undefined;
-        if (typeof value === 'string' && value.trim() === want)
-            return p.propertyName;
-    }
-    return 'html';
-}
-
 debug('seedSdk:db:getPublishPayload');
 /** Case-insensitive dataType match (schema JSON may use "text" vs "Text"). */
 const matchesDataType = (actual, expected) => main_cjs.normalizeDataType(actual) === expected;
+/** True (and the property is deferred) when `targetSeedLocalId` is an item still in progress. */
+function deferIfBackEdge(ctx, property, targetSeedLocalIds) {
+    if (!targetSeedLocalIds.some((id) => !!id && ctx.newSeedsInProgress?.has(id)))
+        return false;
+    ctx.deferredProperties ?? (ctx.deferredProperties = new Set());
+    ctx.deferredProperties.add(property);
+    return true;
+}
 /**
  * Checks the seed a relation/list/image ref points at. A revoked (unpublished) seed is recorded in
  * `ctx.unpublishedRelatedItems`; a live published one maps the ref to its current uid. Returns
  * true when the caller must not walk into the related item (it is published, live or revoked).
  */
 function noteRelatedSeed(ctx, ref, row, propertyName, modelName) {
-    if (isUnpublishedSeed(row)) {
+    if (publishDraftGraph.isUnpublishedSeed(row)) {
         ctx.unpublishedRelatedItems ?? (ctx.unpublishedRelatedItems = []);
         if (!ctx.unpublishedRelatedItems.some((r) => r.propertyName === propertyName && r.seedLocalId === row.seedLocalId)) {
             ctx.unpublishedRelatedItems.push({
@@ -202,7 +116,7 @@ function noteRelatedSeed(ctx, ref, row, propertyName, modelName) {
         }
         return true;
     }
-    if (isLivePublishedSeed(row)) {
+    if (publishDraftGraph.isLivePublishedSeed(row)) {
         if (ref !== row.seedUid) {
             ctx.relatedRefUids ?? (ctx.relatedRefUids = new Map());
             ctx.relatedRefUids.set(ref, row.seedUid);
@@ -296,7 +210,7 @@ async function resolveVersionUid(seedLocalId, seedUid) {
     if (published?.uid)
         return published.uid;
     try {
-        const { getItemVersionsFromEas } = await Promise.resolve().then(function () { return require('./eas-CLiV2Hmn.js'); });
+        const { getItemVersionsFromEas } = await Promise.resolve().then(function () { return require('./eas-CUYXdr2t.js'); });
         const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
         const latest = attestations?.[0];
         if (latest?.id)
@@ -363,7 +277,7 @@ const ensurePropertyDefs = async (targetItem) => {
             schema = await property.getPropertySchema(targetItem.modelName, itemProperty.propertyName, targetScope);
             if (!schema) {
                 try {
-                    const { Model } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
+                    const { Model } = await Promise.resolve().then(function () { return require('./index-Cvvt0-5B.js'); }).then(function (n) { return n.Model$1; });
                     const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(targetItem.modelName));
                     let model = Model.resolve(normalizedModelName, targetScope);
                     if (!model?.properties?.length && !targetScope.modelFileId) {
@@ -439,6 +353,9 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx,
         if (main_cjs.INTERNAL_PROPERTY_NAMES.includes(basicProperty.propertyName)) {
             continue;
         }
+        if (ctx.deferredProperties?.has(basicProperty)) {
+            continue;
+        }
         const snapshot = basicProperty.getService().getSnapshot();
         const context = 'context' in snapshot ? snapshot.context : null;
         const propertyDef = basicProperty.propertyDef ?? (context ? context.propertyRecordSchema : undefined);
@@ -529,7 +446,7 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx,
         }
         // Validate against property validation rules (enum, pattern, minLength, maxLength) before encoding
         if (propertyDef?.validation) {
-            const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+            const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
             const validationService = new SchemaValidationService();
             const validationResult = validationService.validatePropertyValue(value, main_cjs.normalizeDataType(propertyDef.dataType), propertyDef.validation, propertyDef.refValueType
                 ? main_cjs.normalizeDataType(propertyDef.refValueType)
@@ -669,7 +586,7 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
                 matchesDataType(relationOrImageProperty.propertyDef?.refValueType, main_cjs.ModelPropertyDataTypes.Html) ||
                 matchesDataType(relationOrImageProperty.propertyDef?.refValueType, main_cjs.ModelPropertyDataTypes.Json)));
     if (isStorageSeed && (context.seedLocalId || context.seedUid)) {
-        const { getPropertyData: getPropertyDataFromDb } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.getPropertyData; });
+        const { getPropertyData: getPropertyDataFromDb } = await Promise.resolve().then(function () { return require('./index-Cvvt0-5B.js'); }).then(function (n) { return n.getPropertyData; });
         const metaRow = await getPropertyDataFromDb({
             propertyName: relationOrImageProperty.propertyName,
             seedLocalId: context.seedLocalId,
@@ -753,12 +670,15 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         return multiPublishPayload;
     }
     // The local seed, also when the ref is the old uid of a seed published again since.
-    const relatedSeed = await findRelatedSeedRow({ seedLocalId, seedUid });
+    const relatedSeed = await publishDraftGraph.findRelatedSeedRow({ seedLocalId, seedUid });
+    if (!isStorageSeed && deferIfBackEdge(ctx, relationOrImageProperty, [relatedSeed?.seedLocalId ?? seedLocalId])) {
+        return multiPublishPayload;
+    }
     // Use dynamic import to break circular dependency
-    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.js'); });
+    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-z1tHu0hu.js'); });
     const { getItem } = getItemMod;
     const relatedItem = await getItem(relatedSeed ? { seedLocalId: relatedSeed.seedLocalId } : { seedLocalId, seedUid });
-    if (noteRelatedSeed(ctx, normalizedRef, relatedSeed, relationOrImageProperty.propertyName, relatedItem?.modelName ?? relatedModelNameFromDef(relationOrImageProperty.propertyDef))) {
+    if (noteRelatedSeed(ctx, normalizedRef, relatedSeed, relationOrImageProperty.propertyName, relatedItem?.modelName ?? publishDraftGraph.relatedModelNameFromDef(relationOrImageProperty.propertyDef))) {
         return multiPublishPayload;
     }
     // When related item not found (e.g. different DB, not yet created)
@@ -775,7 +695,6 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
     if (relatedItem.seedUid && relatedItem.seedUid !== main_cjs.ZERO_BYTES32) {
         return multiPublishPayload;
     }
-    const versionUid = getVersionUid(relatedItem);
     let modelName;
     if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, main_cjs.ModelPropertyDataTypes.Image)) {
         modelName = 'Image';
@@ -794,68 +713,106 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         addValidationError(ctx, `Model name not found for relation or image property: ${relationOrImageProperty.propertyName}`, relationOrImageProperty.propertyName);
         return multiPublishPayload;
     }
+    return processRelatedDraftItem({
+        relatedItem,
+        modelName,
+        // A storage seed (Image/File/Html/Json item) attests its own basic properties; a related model
+        // item is published with its full property set and the draft items it reaches in turn.
+        fullDraft: !isStorageSeed,
+        link: { publishLocalId: originalSeedLocalId, propertySchemaUid: relationOrImageSchemaUid },
+        reportPropertyName: relationOrImageProperty.propertyName,
+        multiPublishPayload,
+        uploadedTransactions,
+        ctx,
+        buildOpts,
+    });
+};
+/**
+ * The payload of a draft item (no seed uid) a published item refers to, published with it. Its
+ * request fills the referring property (`link`) through propertiesToUpdate. With `fullDraft`, the
+ * item's whole property set is attested: its storage seeds and Html-embedded images, and its own
+ * relation and list properties, whose draft targets are published with it in turn (depth first,
+ * see publishDraftGraph.ts). A draft already in the batch only gains the link.
+ */
+async function processRelatedDraftItem({ relatedItem, modelName, fullDraft, link, reportPropertyName, multiPublishPayload, uploadedTransactions, ctx, buildOpts, }) {
+    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
     const seedSchemaUid = await main_cjs.getEasSchemaUidForModel(modelName);
     if (!seedSchemaUid) {
-        addValidationError(ctx, `Schema UID not found for model: ${modelName}`, relationOrImageProperty.propertyName);
+        addValidationError(ctx, `Schema UID not found for model: ${modelName}`, reportPropertyName);
         return multiPublishPayload;
     }
-    if (mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedItem.seedLocalId, originalSeedLocalId, relationOrImageSchemaUid)) {
+    if (multiPublishPayload.some((p) => p.localId === relatedItem.seedLocalId)) {
+        if (link) {
+            mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedItem.seedLocalId, link.publishLocalId, link.propertySchemaUid);
+        }
         return multiPublishPayload;
     }
     let publishPayload = {
         localId: relatedItem.seedLocalId,
         seedIsRevocable: true,
         versionSchemaUid: main_cjs.VERSION_SCHEMA_UID,
-        seedUid: seedUid || main_cjs.ZERO_BYTES32,
+        seedUid: main_cjs.ZERO_BYTES32,
         seedSchemaUid,
-        versionUid,
+        versionUid: getVersionUid(relatedItem),
         listOfAttestations: [],
-        propertiesToUpdate: [
-            {
-                publishLocalId: originalSeedLocalId,
-                propertySchemaUid: relationOrImageSchemaUid,
-            },
-        ],
+        propertiesToUpdate: link ? [{ ...link }] : [],
     };
-    await ensurePropertyDefs(relatedItem);
-    const { itemBasicProperties, itemUploadProperties, itemImageProperties: relatedStorageSeedProperties } = await getSegmentedItemProperties.getSegmentedItemProperties(relatedItem);
-    // A draft item related to the published one is published with it, including its own
-    // Image/File/Html/Json properties and the images embedded in its Html (as for the item itself).
-    if (!isStorageSeed) {
-        multiPublishPayload = await processRelatedDraftStorageSeeds(relatedItem, relatedStorageSeedProperties, itemBasicProperties, multiPublishPayload, uploadedTransactions, ctx, buildOpts);
-    }
-    const relatedStorageUpload = resolveStorageTransactionUploadSlot(relatedItem, itemUploadProperties);
-    if (relatedStorageUpload) {
-        const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, relatedItem.seedLocalId);
-        if (transactionData) {
-            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);
+    ctx.newSeedsInProgress ?? (ctx.newSeedsInProgress = new Set());
+    ctx.newSeedsInProgress.add(relatedItem.seedLocalId);
+    try {
+        await ensurePropertyDefs(relatedItem);
+        const segmented = await publishDraftGraph.getSegmentedItemProperties(relatedItem);
+        const { itemBasicProperties, itemUploadProperties, itemImageProperties: relatedStorageSeedProperties } = segmented;
+        if (fullDraft) {
+            // Its own Image/File/Html/Json properties and the images embedded in its Html (as for the item itself).
+            multiPublishPayload = await processRelatedDraftStorageSeeds(relatedItem, relatedStorageSeedProperties, itemBasicProperties, multiPublishPayload, uploadedTransactions, ctx, buildOpts);
+            // Its relations and lists: their draft targets are published too (same walk as publishDraftGraph).
+            const { relationProperties, listProperties } = publishDraftGraph.draftWalkProperties(segmented);
+            for (const relationProperty of relationProperties) {
+                multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, relatedItem.seedLocalId, ctx, buildOpts);
+                itemBasicProperties.push(relationProperty);
+            }
+            for (const listProperty of listProperties) {
+                multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, uploadedTransactions, relatedItem.seedLocalId, ctx, buildOpts);
+                itemBasicProperties.push(listProperty);
+            }
         }
-    }
-    for (const p of itemBasicProperties) {
-        if (isStorageTransactionPropertyName(p.propertyName) &&
-            !p.propertyDef &&
-            relatedItem.modelName) {
-            const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId', await main_cjs.getItemModelScope(relatedItem));
-            if (schema) {
-                p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
+        const relatedStorageUpload = resolveStorageTransactionUploadSlot(relatedItem, itemUploadProperties);
+        if (relatedStorageUpload) {
+            const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, relatedItem.seedLocalId);
+            if (transactionData) {
+                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);
+            }
+        }
+        for (const p of itemBasicProperties) {
+            if (isStorageTransactionPropertyName(p.propertyName) &&
+                !p.propertyDef &&
+                relatedItem.modelName) {
+                const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId', await main_cjs.getItemModelScope(relatedItem));
+                if (schema) {
+                    p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
+                }
             }
         }
+        dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
+        publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx, {
+            forceFullSnapshot,
+        });
+    }
+    finally {
+        ctx.newSeedsInProgress.delete(relatedItem.seedLocalId);
     }
-    dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
-    publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx, {
-        forceFullSnapshot,
-    });
     multiPublishPayload.push(publishPayload);
     return multiPublishPayload;
-};
+}
 /**
  * Storage-seed properties (Image/File/Html/Json) of a draft item related to the published one, and
  * the images embedded in its Html (htmlEmbeddedImageCoPublish rows it owns): payloads for their seeds,
@@ -867,7 +824,7 @@ async function processRelatedDraftStorageSeeds(relatedItem, storageSeedPropertie
         multiPublishPayload = await processRelationOrImageProperty(storageSeedProperty, multiPublishPayload, uploadedTransactions, relatedItem.seedLocalId, ctx, buildOpts);
         itemBasicProperties.push(storageSeedProperty);
     }
-    return processHtmlEmbeddedCoPublishImagePayloads(relatedItem, multiPublishPayload, uploadedTransactions, relatedItem.seedLocalId, ctx, buildOpts);
+    return processHtmlEmbeddedCoPublishImagePayloads(relatedItem, multiPublishPayload, uploadedTransactions, ctx, buildOpts);
 }
 async function resolveHtmlPropertySchemaUidByHtmlSeed(item, htmlSeedLocalId, ctx) {
     const want = htmlSeedLocalId.trim();
@@ -889,7 +846,7 @@ async function resolveHtmlPropertySchemaUidByHtmlSeed(item, htmlSeedLocalId, ctx
     addValidationError(ctx, `Could not find Html property for embedded image rewrite (html seed ${want}).`, 'html', 'html_embed_schema');
     return undefined;
 }
-async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx, buildOpts) {
+async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPayload, uploadedTransactions, ctx, buildOpts) {
     const appDb = main_cjs.BaseDb.getAppDb();
     if (!appDb)
         return multiPublishPayload;
@@ -900,7 +857,7 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
     if (rows.length === 0)
         return multiPublishPayload;
     const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
-    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.js'); });
+    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-z1tHu0hu.js'); });
     const { getItem } = getItemMod;
     const doneImages = new Set();
     for (const row of rows) {
@@ -909,10 +866,11 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
         doneImages.add(row.imageSeedLocalId);
         // An embedded image that is already published is not co-published; one whose seed was revoked
         // (unpublished) blocks the publish like an image property pointing at it would.
-        const imageSeed = await findRelatedSeedRow({ seedLocalId: row.imageSeedLocalId });
-        if (noteRelatedSeed(ctx, row.imageSeedLocalId, imageSeed, htmlPropertyNameForHtmlSeed(item, row.htmlSeedLocalId), 'Image')) {
+        const imageSeed = await publishDraftGraph.findRelatedSeedRow({ seedLocalId: row.imageSeedLocalId });
+        if (noteRelatedSeed(ctx, row.imageSeedLocalId, imageSeed, publishDraftGraph.htmlPropertyNameForHtmlSeed(item, row.htmlSeedLocalId), 'Image')) {
             continue;
         }
+        // The row's Html seed must still be the value of one of the item's Html properties.
         const htmlSchemaUid = await resolveHtmlPropertySchemaUidByHtmlSeed(item, row.htmlSeedLocalId, ctx);
         if (!htmlSchemaUid)
             continue;
@@ -929,10 +887,16 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
             addValidationError(ctx, `Schema UID not found for model: Image`, 'html');
             continue;
         }
-        if (mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedItem.seedLocalId, originalSeedLocalId, htmlSchemaUid)) {
+        // Already in the batch (e.g. also the value of an Image property): its payload is there.
+        if (multiPublishPayload.some((p) => p.localId === relatedItem.seedLocalId)) {
             continue;
         }
         const versionUid = getVersionUid(relatedItem);
+        // No propertiesToUpdate: the Html refers to the image by its Arweave URL (the data URI is
+        // rewritten to it before the Html is uploaded), not by seed uid. The Html property holds the Html
+        // storage seed's uid, which the Html seed's own request writes into it; the contract writes each
+        // updater's seed uid into the same data[0] (SeedPublishLib.setSeedReference), so an image
+        // targeting the Html property too would overwrite that reference with the image's seed uid.
         let publishPayload = {
             localId: relatedItem.seedLocalId,
             seedIsRevocable: true,
@@ -941,15 +905,10 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
             seedSchemaUid,
             versionUid,
             listOfAttestations: [],
-            propertiesToUpdate: [
-                {
-                    publishLocalId: originalSeedLocalId,
-                    propertySchemaUid: htmlSchemaUid,
-                },
-            ],
+            propertiesToUpdate: [],
         };
         await ensurePropertyDefs(relatedItem);
-        const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties.getSegmentedItemProperties(relatedItem);
+        const { itemBasicProperties, itemUploadProperties } = await publishDraftGraph.getSegmentedItemProperties(relatedItem);
         const relatedStorageUpload = resolveStorageTransactionUploadSlot(relatedItem, itemUploadProperties);
         if (relatedStorageUpload) {
             const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, relatedItem.seedLocalId);
@@ -981,7 +940,7 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
     }
     return multiPublishPayload;
 }
-const processListProperty = async (listProperty, multiPublishPayload, originalSeedLocalId, ctx, buildOpts) => {
+const processListProperty = async (listProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx, buildOpts) => {
     const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
     // processListProperty only handles list-of-relations; list-of-primitives go to itemBasicProperties
     if (!listProperty.propertyDef?.ref) {
@@ -1014,6 +973,7 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         : value != null
             ? [value]
             : [];
+    const members = [];
     for (const seedId of iterableValue) {
         const idStr = typeof seedId === 'string'
             ? seedId
@@ -1025,12 +985,23 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         const { localId: seedLocalId, uid: seedUid } = main_cjs.getCorrectId(idStr);
         if (!seedLocalId && !seedUid)
             continue;
-        const relatedSeed = await findRelatedSeedRow({ seedLocalId, seedUid });
+        members.push({ idStr, seedLocalId, seedUid });
+    }
+    // A member that is an item still in progress (a cycle back to it) can't be attested in this
+    // publish, so the list is deferred; its other draft members are still published, unlinked.
+    const memberSeeds = await Promise.all(members.map((m) => publishDraftGraph.findRelatedSeedRow({ seedLocalId: m.seedLocalId, seedUid: m.seedUid })));
+    const deferred = deferIfBackEdge(ctx, listProperty, members.map((m, i) => memberSeeds[i]?.seedLocalId ?? m.seedLocalId));
+    for (let i = 0; i < members.length; i++) {
+        const { idStr, seedLocalId, seedUid } = members[i];
+        const relatedSeed = memberSeeds[i] ?? null;
+        const memberLocalId = relatedSeed?.seedLocalId ?? seedLocalId;
+        if (memberLocalId && ctx.newSeedsInProgress?.has(memberLocalId))
+            continue;
         // Use dynamic import to break circular dependency
-        const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.js'); });
+        const getItemMod = await Promise.resolve().then(function () { return require('./getItem-z1tHu0hu.js'); });
         const { getItem } = getItemMod;
         const relatedItem = await getItem(relatedSeed ? { seedLocalId: relatedSeed.seedLocalId } : { seedLocalId, seedUid });
-        if (noteRelatedSeed(ctx, idStr.trim(), relatedSeed, listProperty.propertyName, relatedItem?.modelName ?? relatedModelNameFromDef(listProperty.propertyDef))) {
+        if (noteRelatedSeed(ctx, idStr.trim(), relatedSeed, listProperty.propertyName, relatedItem?.modelName ?? publishDraftGraph.relatedModelNameFromDef(listProperty.propertyDef))) {
             continue;
         }
         if (!relatedItem) {
@@ -1043,7 +1014,6 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         if (relatedItem.seedUid && relatedItem.seedUid !== main_cjs.ZERO_BYTES32) {
             continue;
         }
-        const versionUid = getVersionUid(relatedItem);
         let modelName;
         if (listProperty.propertyDef?.ref || listProperty.propertyDef.refModelName) {
             const def = listProperty.propertyDef;
@@ -1062,36 +1032,17 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
             addValidationError(ctx, `Model name not found for list property: ${listProperty.propertyName}`, listProperty.propertyName);
             continue;
         }
-        const seedSchemaUid = await main_cjs.getEasSchemaUidForModel(modelName);
-        if (!seedSchemaUid) {
-            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,
-            versionSchemaUid: main_cjs.VERSION_SCHEMA_UID,
-            seedUid: seedUid || main_cjs.ZERO_BYTES32,
-            seedSchemaUid,
-            versionUid,
-            listOfAttestations: [],
-            propertiesToUpdate: [
-                {
-                    publishLocalId: originalSeedLocalId,
-                    propertySchemaUid: listPropertySchemaUid,
-                },
-            ],
-        };
-        await ensurePropertyDefs(relatedItem);
-        const { itemBasicProperties } = await getSegmentedItemProperties.getSegmentedItemProperties(relatedItem);
-        dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
-        publishPayload = await processBasicProperties(itemBasicProperties, publishPayload, ctx, {
-            forceFullSnapshot,
+        multiPublishPayload = await processRelatedDraftItem({
+            relatedItem,
+            modelName,
+            fullDraft: true,
+            link: deferred ? null : { publishLocalId: originalSeedLocalId, propertySchemaUid: listPropertySchemaUid },
+            reportPropertyName: listProperty.propertyName,
+            multiPublishPayload,
+            uploadedTransactions,
+            ctx,
+            buildOpts,
         });
-        multiPublishPayload.push(publishPayload);
     }
     return multiPublishPayload;
 };
@@ -1228,13 +1179,18 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
     // A revoked seed can't be published under again: republishing creates a new seed attestation
     // (new seedUid) and a new version carrying every property (see docs/ATTESTATION_REVOCATION.md).
     const hasSeedUid = !!item.seedUid && item.seedUid !== main_cjs.ZERO_BYTES32;
-    const republishRevokedSeed = hasSeedUid && (await isSeedRevoked(item.seedLocalId));
+    const republishRevokedSeed = hasSeedUid && (await publishDraftGraph.isSeedRevoked(item.seedLocalId));
     const rootSeedUid = republishRevokedSeed ? main_cjs.ZERO_BYTES32 : item.seedUid || main_cjs.ZERO_BYTES32;
     const forceFullSnapshot = publishMode === 'new_version' || republishRevokedSeed;
     if (publishMode === 'new_version' && (!item.seedUid || item.seedUid === main_cjs.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 = [];
+    // The root gets a new seed (draft, or revoked seed published again): related drafts referring
+    // back to it can't attest its uid in this publish (see publishDraftGraph.ts).
+    if (rootSeedUid === main_cjs.ZERO_BYTES32) {
+        validationCtx.newSeedsInProgress = new Set([item.seedLocalId]);
+    }
     // Each PublishPayload is generated from a Seed that needs publishing
     // First we need to determine all Seeds to publish
     // That means the Seed of the Item, plus any Seeds pointed to by Relations
@@ -1268,7 +1224,7 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         propertiesToUpdate: [],
     };
     await ensurePropertyDefs(item);
-    const { itemBasicProperties, itemListProperties, itemUploadProperties, itemImageProperties, itemRelationProperties, } = await getSegmentedItemProperties.getSegmentedItemProperties(item);
+    const { itemBasicProperties, itemListProperties, itemUploadProperties, itemImageProperties, itemRelationProperties, } = await publishDraftGraph.getSegmentedItemProperties(item);
     const relationAndImageProperties = [...itemRelationProperties, ...itemImageProperties];
     // Validate required relations have values before processing
     for (const relProp of itemRelationProperties) {
@@ -1317,9 +1273,9 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx, { forceFullSnapshot });
         itemBasicProperties.push(relationProperty);
     }
-    multiPublishPayload = await processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx, { forceFullSnapshot });
+    multiPublishPayload = await processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPayload, uploadedTransactions, validationCtx, { forceFullSnapshot });
     for (const listProperty of itemListProperties) {
-        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, item.seedLocalId, validationCtx, { forceFullSnapshot });
+        multiPublishPayload = await processListProperty(listProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx, { forceFullSnapshot });
         itemBasicProperties.push(listProperty);
     }
     for (const p of itemBasicProperties) {
@@ -1638,4 +1594,4 @@ exports.PublishValidationFailedError = PublishValidationFailedError;
 exports.getPublishPayload = getPublishPayload;
 exports.resolvePublishPayloadValues = resolvePublishPayloadValues;
 exports.validateItemForPublish = validateItemForPublish;
-//# sourceMappingURL=getPublishPayload-D5-dYtNq.js.map
+//# sourceMappingURL=getPublishPayload-CEP_e-Kv.js.map