@seedprotocol/sdk 0.6.10 → 0.7.1

package/dist/{getPublishPayload-BIrTVUxb.js → getPublishPayload-76_KfB5Y.js}

@@ -1,30 +1,20 @@
-import { Z as ZERO_BYTES32, a as BaseDb, m as models, p as properties, V as VERSION_SCHEMA_UID, h as htmlEmbeddedImageCoPublish, I as INTERNAL_PROPERTY_NAMES, w as defaultAttestationData, x as INTERNAL_DATA_TYPES } from './BasePathResolver-B6CKqoKw.js';
+import { p as resolveModelRecord, q as getItemModelScope, M as ModelPropertyDataTypes, n as normalizeDataType } from './db-Lw0KVZmc.js';
+import { Z as ZERO_BYTES32, B as BaseDb, p as properties, V as VERSION_SCHEMA_UID, j as models, h as htmlEmbeddedImageCoPublish, I as INTERNAL_PROPERTY_NAMES, w as defaultAttestationData, x as INTERNAL_DATA_TYPES } from './BasePathResolver-DRT09oVv.js';
 import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
-import { r as resolveSeedIdsFromRefString, n as normalizeRelationPropertyValue, i as isPublishedSeedRef, g as getCorrectId, a as isStorageSeedRef, t as toSnakeCase$1 } from './index-280bL-n4.js';
+import { r as resolveSeedIdsFromRefString, n as normalizeRelationPropertyValue, i as isPublishedSeedRef, g as getCorrectId, a as isStorageSeedRef, t as toSnakeCase$1 } from './tabEvents-C6NXS6Jl.js';
 import { toSnakeCase } from 'drizzle-orm/casing';
-import { b as getEasSchemaUidForModel, c as getLatestPublishedVersionRow, p as parseListPropertyValueFromStorage, l as listRelationEasPropertyName } from './ClientManager-ChcmUL47.js';
+import { a as getEasSchemaUidForModel, b as getLatestPublishedVersionRow, p as parseListPropertyValueFromStorage, l as listRelationEasPropertyName } from './Item-ZUAmf943.js';
 import { isValidEasAttestationUid, getEasSchemaUidForSchemaDefinition } from '@seedprotocol/eas';
-import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-BmKE71vU.js';
-import { getPropertySchema } from './property-CQjuZ4JW.js';
+import { i as isSeedRevoked, a as getSegmentedItemProperties, f as findRelatedSeedRow, r as relatedModelNameFromDef, h as htmlPropertyNameForHtmlSeed, b as isUnpublishedSeed, c as isLivePublishedSeed, d as draftWalkProperties } from './publishDraftGraph-BRm6Pq3Q.js';
+import { getPropertySchema } from './property-ByaiSyUK.js';
 import { modelPropertiesToObject } from './model-DGMe-TTm.js';
 import { upperFirst, camelCase } from 'lodash-es';
-import { eq, and, sql } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import debug from 'debug';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
 import 'reflect-metadata';
-import './index-HRHkbVQd.js';
-import { M as ModelPropertyDataTypes, n as normalizeDataType } from './db-WbrzEf7c.js';
-import 'drizzle-orm/sqlite-core';
-import '@seedprotocol/arweave';
-import 'xstate';
-import 'pluralize';
-import 'nanoid';
-import 'nanoid-dictionary';
-import '@seedprotocol/query';
-import './generateId-BopUwD8F.js';
-import 'rxjs';
-import '@sinclair/typebox';
+import './index-Y-yYyRBf.js';
 
 /** UTF-8 string to 0x-prefixed bytes32 hex (right-padded with zeros). */
 function encodeBytes32String(value) {
@@ -38,11 +28,88 @@ function encodeBytes32String(value) {
     return `0x${hex.padEnd(64, '0')}`;
 }
 
-// Dynamic import to break circular dependency with getItem -> BaseItem
-// import { getItem } from '@/db/read/getItem'
+/** Error thrown when publish validation fails. Includes all validation errors for user to fix. */
+class PublishValidationFailedError extends Error {
+    constructor(message, validationErrors) {
+        super(message);
+        this.validationErrors = validationErrors;
+        this.name = 'PublishValidationFailedError';
+    }
+}
+/** Validation error code for a relation, list member or image/file ref to an unpublished seed. */
+const RELATED_ITEM_UNPUBLISHED_CODE = 'related_item_unpublished';
+const describeUnpublishedRelatedItem = (r) => `${r.propertyName} -> ${r.modelName} ${r.seedLocalId} (seed ${r.seedUid})`;
+/**
+ * Thrown before anything is uploaded or attested when the item references items whose seed was
+ * unpublished: the parent would attest a revoked seed uid. Republish those items (which gives
+ * them a new seed uid) or remove the references, then publish again.
+ * See docs/ATTESTATION_REVOCATION.md ("Republishing").
+ *
+ * A PublishValidationFailedError, so validateItemForPublish and the publish package's checking
+ * step report it as validation errors (code `related_item_unpublished`, one per reference).
+ */
+class RelatedItemUnpublishedError extends PublishValidationFailedError {
+    constructor(unpublishedRelatedItems, otherValidationErrors = []) {
+        const lines = unpublishedRelatedItems.map(describeUnpublishedRelatedItem);
+        const message = `Cannot publish: it references ${lines.length} unpublished item${lines.length === 1 ? '' : 's'} ` +
+            `(their seed attestations were revoked). Republish them or remove the references, then publish again:\n` +
+            lines.join('\n');
+        super(message, [
+            ...unpublishedRelatedItems.map((r) => ({
+                field: r.propertyName,
+                message: `${r.propertyName} references unpublished ${r.modelName} ${r.seedLocalId} (seed ${r.seedUid}). ` +
+                    `Republish it or remove the reference.`,
+                code: RELATED_ITEM_UNPUBLISHED_CODE,
+            })),
+            ...otherValidationErrors,
+        ]);
+        this.name = 'RelatedItemUnpublishedError';
+        this.unpublishedRelatedItems = unpublishedRelatedItems;
+    }
+}
+
 debug('seedSdk:db:getPublishPayload');
 /** Case-insensitive dataType match (schema JSON may use "text" vs "Text"). */
 const matchesDataType = (actual, expected) => 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)) {
+        ctx.unpublishedRelatedItems ?? (ctx.unpublishedRelatedItems = []);
+        if (!ctx.unpublishedRelatedItems.some((r) => r.propertyName === propertyName && r.seedLocalId === row.seedLocalId)) {
+            ctx.unpublishedRelatedItems.push({
+                propertyName,
+                modelName: modelName ?? row.type ?? 'unknown',
+                seedLocalId: row.seedLocalId,
+                seedUid: row.seedUid,
+            });
+        }
+        return true;
+    }
+    if (isLivePublishedSeed(row)) {
+        if (ref !== row.seedUid) {
+            ctx.relatedRefUids ?? (ctx.relatedRefUids = new Map());
+            ctx.relatedRefUids.set(ref, row.seedUid);
+        }
+        return true;
+    }
+    return false;
+}
+/** Current uid for a ref noted by noteRelatedSeed, else the ref itself. */
+function currentRelatedRef(ctx, ref) {
+    return ctx.relatedRefUids?.get(ref.trim()) ?? ref;
+}
 function addValidationError(ctx, message, field, code = 'publish_validation') {
     // A property can be validated on more than one path (List of Relation: list + basic); report once.
     if (ctx.errors.some((e) => e.message === message && e.field === (field ?? '')))
@@ -124,7 +191,7 @@ async function resolveVersionUid(seedLocalId, seedUid) {
     if (published?.uid)
         return published.uid;
     try {
-        const { getItemVersionsFromEas } = await import('./eas-CfYCu4IX.js');
+        const { getItemVersionsFromEas } = await import('./eas-CQ-Smzk2.js');
         const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
         const latest = attestations?.[0];
         if (latest?.id)
@@ -184,17 +251,19 @@ const ensurePropertyDefs = async (targetItem) => {
             (matchesDataType(p.propertyDef?.dataType, ModelPropertyDataTypes.Relation) &&
                 p.propertyDef?.required === undefined)));
     let schema;
+    // Model names are only unique per schema: resolve definitions from this item's own model.
+    const targetScope = await getItemModelScope(targetItem);
     for (const itemProperty of targetItem.properties) {
         if (!itemProperty.propertyDef && targetItem.modelName) {
-            schema = await getPropertySchema(targetItem.modelName, itemProperty.propertyName);
+            schema = await getPropertySchema(targetItem.modelName, itemProperty.propertyName, targetScope);
             if (!schema) {
                 try {
-                    const _mod_0 = await import('./index-HRHkbVQd.js');
-                    const _ns_0 = _mod_0.b;
+                    const _mod_0 = await import('./index-Y-yYyRBf.js');
+                    const _ns_0 = _mod_0.f;
                     const { Model } = _ns_0;
                     const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
-                    let model = Model.getByName(normalizedModelName);
-                    if (!model?.properties?.length) {
+                    let model = Model.resolve(normalizedModelName, targetScope);
+                    if (!model?.properties?.length && !targetScope.modelFileId) {
                         model = Model.findByModelType(toSnakeCase(targetItem.modelName));
                     }
                     const modelFound = !!model;
@@ -215,11 +284,8 @@ const ensurePropertyDefs = async (targetItem) => {
                 if (db) {
                     try {
                         const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
-                        const modelRecords = await db
-                            .select({ id: models.id })
-                            .from(models)
-                            .where(eq(models.name, normalizedModelName))
-                            .limit(1);
+                        const modelRecord = await resolveModelRecord(normalizedModelName, targetScope, db);
+                        const modelRecords = modelRecord ? [modelRecord] : [];
                         if (modelRecords.length > 0 && modelRecords[0].id) {
                             const propertyRecords = await db
                                 .select()
@@ -270,6 +336,9 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx,
         if (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);
@@ -350,13 +419,17 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx,
                 .map((s) => s.trim())
                 .filter(Boolean);
         }
+        // A ref to a published related item attests that item's current uid.
+        if (typeof value === 'string' && (isRelation || isFileImageHtml || isJsonStorage)) {
+            value = currentRelatedRef(ctx, value);
+        }
         if (schemaDef.startsWith('bytes32[]') && !Array.isArray(value)) {
             addValidationError(ctx, `Invalid value for property: ${basicProperty.propertyName}. Expected an array of bytes32, got ${value}.`, basicProperty.propertyName);
             continue;
         }
         // Validate against property validation rules (enum, pattern, minLength, maxLength) before encoding
         if (propertyDef?.validation) {
-            const { SchemaValidationService } = await import('./SchemaValidationService-Y49vqast.js');
+            const { SchemaValidationService } = await import('./SchemaValidationService-IoS7JquP.js');
             const validationService = new SchemaValidationService();
             const validationResult = validationService.validatePropertyValue(value, normalizeDataType(propertyDef.dataType), propertyDef.validation, propertyDef.refValueType
                 ? normalizeDataType(propertyDef.refValueType)
@@ -387,7 +460,7 @@ const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx,
                         : '';
                 if (!idStr)
                     continue;
-                const trimmed = idStr.trim();
+                const trimmed = currentRelatedRef(ctx, idStr.trim());
                 if (!trimmed)
                     continue;
                 rawIds.push(trimmed);
@@ -496,8 +569,8 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
                 matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.Html) ||
                 matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.Json)));
     if (isStorageSeed && (context.seedLocalId || context.seedUid)) {
-        const _mod_1 = await import('./ClientManager-ChcmUL47.js');
-        const _ns_1 = _mod_1.al;
+        const _mod_1 = await import('./Item-ZUAmf943.js');
+        const _ns_1 = _mod_1.Y;
         const { getPropertyData: getPropertyDataFromDb } = _ns_1;
         const metaRow = await getPropertyDataFromDb({
             propertyName: relationOrImageProperty.propertyName,
@@ -520,14 +593,12 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
     let isRequired = propertyDef?.required === true;
     // Resolve required from schema/DB when propertyDef lacks it
     if (!isRequired && relationOrImageProperty.modelName) {
-        let schema = await getPropertySchema(relationOrImageProperty.modelName, relationOrImageProperty.propertyName);
+        const propertyScope = await getItemModelScope(relationOrImageProperty);
+        let schema = await getPropertySchema(relationOrImageProperty.modelName, relationOrImageProperty.propertyName, propertyScope);
         if (!schema && BaseDb.getAppDb()) {
             const normalizedModelName = upperFirst(camelCase(relationOrImageProperty.modelName));
-            const modelRecords = await BaseDb.getAppDb()
-                .select({ id: models.id })
-                .from(models)
-                .where(eq(models.name, normalizedModelName))
-                .limit(1);
+            const modelRecord = await resolveModelRecord(normalizedModelName, propertyScope);
+            const modelRecords = modelRecord ? [modelRecord] : [];
             if (modelRecords.length > 0 && modelRecords[0].id) {
                 const propertyRecords = await BaseDb.getAppDb()
                     .select()
@@ -583,13 +654,18 @@ 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 });
+    if (!isStorageSeed && deferIfBackEdge(ctx, relationOrImageProperty, [relatedSeed?.seedLocalId ?? seedLocalId])) {
+        return multiPublishPayload;
+    }
     // Use dynamic import to break circular dependency
-    const getItemMod = await import('./getItem-Br-bGNFO.js');
+    const getItemMod = await import('./getItem-CSfSok9f.js');
     const { getItem } = getItemMod;
-    const relatedItem = await getItem({
-        seedLocalId,
-        seedUid,
-    });
+    const relatedItem = await getItem(relatedSeed ? { seedLocalId: relatedSeed.seedLocalId } : { seedLocalId, seedUid });
+    if (noteRelatedSeed(ctx, normalizedRef, relatedSeed, relationOrImageProperty.propertyName, relatedItem?.modelName ?? relatedModelNameFromDef(relationOrImageProperty.propertyDef))) {
+        return multiPublishPayload;
+    }
     // When related item not found (e.g. different DB, not yet created)
     if (!relatedItem) {
         // An attested uid with no local copy is already published; the parent attests the uid as-is.
@@ -604,7 +680,6 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
     if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
         return multiPublishPayload;
     }
-    const versionUid = getVersionUid(relatedItem);
     let modelName;
     if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Image)) {
         modelName = 'Image';
@@ -623,63 +698,119 @@ 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 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: VERSION_SCHEMA_UID,
-        seedUid: seedUid || ZERO_BYTES32,
+        seedUid: ZERO_BYTES32,
         seedSchemaUid,
-        versionUid,
+        versionUid: getVersionUid(relatedItem),
         listOfAttestations: [],
-        propertiesToUpdate: [
-            {
-                publishLocalId: originalSeedLocalId,
-                propertySchemaUid: relationOrImageSchemaUid,
-            },
-        ],
+        propertiesToUpdate: link ? [{ ...link }] : [],
     };
-    await ensurePropertyDefs(relatedItem);
-    const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties(relatedItem);
-    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 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 } = 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 getPropertySchema(relatedItem.modelName, 'storageTransactionId');
-            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 getPropertySchema(relatedItem.modelName, 'storageTransactionId', await 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,
+ * and the properties added to `itemBasicProperties` so the related item attests them. Same handling
+ * as the published item's own (see getPublishPayload).
+ */
+async function processRelatedDraftStorageSeeds(relatedItem, storageSeedProperties, itemBasicProperties, multiPublishPayload, uploadedTransactions, ctx, buildOpts) {
+    for (const storageSeedProperty of storageSeedProperties) {
+        multiPublishPayload = await processRelationOrImageProperty(storageSeedProperty, multiPublishPayload, uploadedTransactions, relatedItem.seedLocalId, ctx, buildOpts);
+        itemBasicProperties.push(storageSeedProperty);
+    }
+    return processHtmlEmbeddedCoPublishImagePayloads(relatedItem, multiPublishPayload, uploadedTransactions, ctx, buildOpts);
+}
 async function resolveHtmlPropertySchemaUidByHtmlSeed(item, htmlSeedLocalId, ctx) {
     const want = htmlSeedLocalId.trim();
     for (const p of item.properties) {
@@ -700,7 +831,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 = BaseDb.getAppDb();
     if (!appDb)
         return multiPublishPayload;
@@ -711,13 +842,20 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
     if (rows.length === 0)
         return multiPublishPayload;
     const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
-    const getItemMod = await import('./getItem-Br-bGNFO.js');
+    const getItemMod = await import('./getItem-CSfSok9f.js');
     const { getItem } = getItemMod;
     const doneImages = new Set();
     for (const row of rows) {
         if (doneImages.has(row.imageSeedLocalId))
             continue;
         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')) {
+            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;
@@ -734,10 +872,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,
@@ -746,12 +890,7 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
             seedSchemaUid,
             versionUid,
             listOfAttestations: [],
-            propertiesToUpdate: [
-                {
-                    publishLocalId: originalSeedLocalId,
-                    propertySchemaUid: htmlSchemaUid,
-                },
-            ],
+            propertiesToUpdate: [],
         };
         await ensurePropertyDefs(relatedItem);
         const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties(relatedItem);
@@ -772,7 +911,7 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
             if (isStorageTransactionPropertyName(p.propertyName) &&
                 !p.propertyDef &&
                 relatedItem.modelName) {
-                const schema = await getPropertySchema(relatedItem.modelName, 'storageTransactionId');
+                const schema = await getPropertySchema(relatedItem.modelName, 'storageTransactionId', await getItemModelScope(relatedItem));
                 if (schema) {
                     p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
                 }
@@ -786,7 +925,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) {
@@ -819,6 +958,7 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         : value != null
             ? [value]
             : [];
+    const members = [];
     for (const seedId of iterableValue) {
         const idStr = typeof seedId === 'string'
             ? seedId
@@ -830,13 +970,25 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         const { localId: seedLocalId, uid: seedUid } = getCorrectId(idStr);
         if (!seedLocalId && !seedUid)
             continue;
+        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) => 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 import('./getItem-Br-bGNFO.js');
+        const getItemMod = await import('./getItem-CSfSok9f.js');
         const { getItem } = getItemMod;
-        const relatedItem = await getItem({
-            seedLocalId,
-            seedUid,
-        });
+        const relatedItem = await getItem(relatedSeed ? { seedLocalId: relatedSeed.seedLocalId } : { seedLocalId, seedUid });
+        if (noteRelatedSeed(ctx, idStr.trim(), relatedSeed, listProperty.propertyName, relatedItem?.modelName ?? relatedModelNameFromDef(listProperty.propertyDef))) {
+            continue;
+        }
         if (!relatedItem) {
             // An attested uid with no local copy is already published; the list attests the uid as-is.
             if (!isPublishedSeedRef(idStr)) {
@@ -847,7 +999,6 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
         if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
             continue;
         }
-        const versionUid = getVersionUid(relatedItem);
         let modelName;
         if (listProperty.propertyDef?.ref || listProperty.propertyDef.refModelName) {
             const def = listProperty.propertyDef;
@@ -866,36 +1017,17 @@ const processListProperty = async (listProperty, multiPublishPayload, originalSe
             addValidationError(ctx, `Model name not found for list property: ${listProperty.propertyName}`, listProperty.propertyName);
             continue;
         }
-        const seedSchemaUid = await 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: VERSION_SCHEMA_UID,
-            seedUid: seedUid || ZERO_BYTES32,
-            seedSchemaUid,
-            versionUid,
-            listOfAttestations: [],
-            propertiesToUpdate: [
-                {
-                    publishLocalId: originalSeedLocalId,
-                    propertySchemaUid: listPropertySchemaUid,
-                },
-            ],
-        };
-        await ensurePropertyDefs(relatedItem);
-        const { itemBasicProperties } = await 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;
 };
@@ -1026,22 +1158,24 @@ function findUploadedTxForSeedLocalId(uploadedTransactions, seedLocalId) {
     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) {
-        super(message);
-        this.validationErrors = validationErrors;
-        this.name = 'PublishValidationFailedError';
-    }
-}
 const getPublishPayload = async (item, uploadedTransactions, options) => {
     const validationCtx = { errors: [] };
     const publishMode = options?.publishMode ?? 'patch';
-    const forceFullSnapshot = publishMode === 'new_version';
+    // 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 !== ZERO_BYTES32;
+    const republishRevokedSeed = hasSeedUid && (await isSeedRevoked(item.seedLocalId));
+    const rootSeedUid = republishRevokedSeed ? ZERO_BYTES32 : item.seedUid || ZERO_BYTES32;
+    const forceFullSnapshot = publishMode === 'new_version' || republishRevokedSeed;
     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 = [];
+    // 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 === 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
@@ -1058,15 +1192,15 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         }
     }
     let versionUid = getVersionUid(item);
-    if (versionUid === ZERO_BYTES32 && item.seedUid && item.seedUid !== ZERO_BYTES32) {
-        versionUid = await resolveVersionUid(item.seedLocalId, item.seedUid);
+    if (versionUid === ZERO_BYTES32 && rootSeedUid !== ZERO_BYTES32) {
+        versionUid = await resolveVersionUid(item.seedLocalId, rootSeedUid);
     }
-    if (forceFullSnapshot && item.seedUid && item.seedUid !== ZERO_BYTES32) {
+    if (forceFullSnapshot && hasSeedUid) {
         versionUid = ZERO_BYTES32;
     }
     let itemPublishData = {
         localId: item.seedLocalId,
-        seedUid: item.seedUid || ZERO_BYTES32,
+        seedUid: rootSeedUid,
         seedIsRevocable: true,
         seedSchemaUid: itemSchemaUid,
         versionSchemaUid: VERSION_SCHEMA_UID,
@@ -1088,11 +1222,8 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         let isRequired = relProp.propertyDef?.required === true;
         if (!isRequired && BaseDb.getAppDb() && item.modelName) {
             const normalizedModelName = upperFirst(camelCase(item.modelName));
-            const modelRows = await BaseDb.getAppDb()
-                .select({ id: models.id })
-                .from(models)
-                .where(eq(models.name, normalizedModelName))
-                .limit(1);
+            const modelRecord = await resolveModelRecord(normalizedModelName, await getItemModelScope(item));
+            const modelRows = modelRecord ? [modelRecord] : [];
             if (modelRows.length > 0) {
                 const propRows = await BaseDb.getAppDb()
                     .select({ required: properties.required, refModelId: properties.refModelId })
@@ -1127,14 +1258,14 @@ 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) {
         if (isStorageTransactionPropertyName(p.propertyName) && !p.propertyDef && item.modelName) {
-            const schema = await getPropertySchema(item.modelName, 'storageTransactionId');
+            const schema = await getPropertySchema(item.modelName, 'storageTransactionId', await getItemModelScope(item));
             if (schema) {
                 p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
             }
@@ -1160,6 +1291,10 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
                 'Ensure required fields have values and that publishable properties are present.', 'listOfAttestations', 'publish_new_version_empty_snapshot');
         }
     }
+    // Stop before anything is uploaded or attested: the payload would attest revoked seed uids.
+    if (validationCtx.unpublishedRelatedItems?.length) {
+        throw new RelatedItemUnpublishedError(validationCtx.unpublishedRelatedItems, validationCtx.errors);
+    }
     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);
@@ -1440,5 +1575,13 @@ const resolvePublishPayloadValues = async (multiPayload, resolvedUids) => {
     return result;
 };
 
-export { PublishValidationFailedError, getPublishPayload, resolvePublishPayloadValues, validateItemForPublish };
-//# sourceMappingURL=getPublishPayload-BIrTVUxb.js.map
+var getPublishPayload$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    PublishValidationFailedError: PublishValidationFailedError,
+    getPublishPayload: getPublishPayload,
+    resolvePublishPayloadValues: resolvePublishPayloadValues,
+    validateItemForPublish: validateItemForPublish
+});
+
+export { PublishValidationFailedError as P, RELATED_ITEM_UNPUBLISHED_CODE as R, RelatedItemUnpublishedError as a, getPublishPayload$1 as g, resolvePublishPayloadValues as r, validateItemForPublish as v };
+//# sourceMappingURL=getPublishPayload-76_KfB5Y.js.map