@seedprotocol/sdk 0.6.9 → 0.7.0

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

@@ -1,22 +1,22 @@
 'use strict';
 
-var main_cjs = require('./index-CSNtEnbF.js');
+var main_cjs = require('./index-C66AfYDG.js');
 var easSdk = require('@ethereum-attestation-service/eas-sdk');
 var casing = require('drizzle-orm/casing');
 var eas = require('@seedprotocol/eas');
-var getSegmentedItemProperties = require('./getSegmentedItemProperties-CU8rtBAo.js');
-var property = require('./property-DlKiAWt4.js');
-var lodashEs = require('lodash-es');
 var drizzleOrm = require('drizzle-orm');
+var getSegmentedItemProperties = require('./getSegmentedItemProperties-giHO7R3d.js');
+var property = require('./property-BVJIP7SX.js');
+var lodashEs = require('lodash-es');
 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,6 +35,25 @@ 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);
@@ -47,11 +66,155 @@ 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;
+    }
+}
+
+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;
+/**
+ * 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 ?? '')))
@@ -133,7 +296,7 @@ async function resolveVersionUid(seedLocalId, seedUid) {
     if (published?.uid)
         return published.uid;
     try {
-        const { getItemVersionsFromEas } = await Promise.resolve().then(function () { return require('./eas-CMNppmGE.js'); });
+        const { getItemVersionsFromEas } = await Promise.resolve().then(function () { return require('./eas-CLiV2Hmn.js'); });
         const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
         const latest = attestations?.[0];
         if (latest?.id)
@@ -193,15 +356,17 @@ const ensurePropertyDefs = async (targetItem) => {
             (matchesDataType(p.propertyDef?.dataType, main_cjs.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 main_cjs.getItemModelScope(targetItem);
     for (const itemProperty of targetItem.properties) {
         if (!itemProperty.propertyDef && targetItem.modelName) {
-            schema = await property.getPropertySchema(targetItem.modelName, itemProperty.propertyName);
+            schema = await property.getPropertySchema(targetItem.modelName, itemProperty.propertyName, targetScope);
             if (!schema) {
                 try {
-                    const { Model } = await Promise.resolve().then(function () { return require('./index-CSNtEnbF.js'); }).then(function (n) { return n.Model$1; });
+                    const { Model } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.Model$1; });
                     const normalizedModelName = lodashEs.upperFirst(lodashEs.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(casing.toSnakeCase(targetItem.modelName));
                     }
                     const modelFound = !!model;
@@ -222,11 +387,8 @@ const ensurePropertyDefs = async (targetItem) => {
                 if (db) {
                     try {
                         const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(targetItem.modelName));
-                        const modelRecords = await db
-                            .select({ id: main_cjs.models.id })
-                            .from(main_cjs.models)
-                            .where(drizzleOrm.eq(main_cjs.models.name, normalizedModelName))
-                            .limit(1);
+                        const modelRecord = await main_cjs.resolveModelRecord(normalizedModelName, targetScope, db);
+                        const modelRecords = modelRecord ? [modelRecord] : [];
                         if (modelRecords.length > 0 && modelRecords[0].id) {
                             const propertyRecords = await db
                                 .select()
@@ -357,13 +519,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 Promise.resolve().then(function () { return require('./SchemaValidationService-DtYs_CNY.js'); });
+            const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
             const validationService = new SchemaValidationService();
             const validationResult = validationService.validatePropertyValue(value, main_cjs.normalizeDataType(propertyDef.dataType), propertyDef.validation, propertyDef.refValueType
                 ? main_cjs.normalizeDataType(propertyDef.refValueType)
@@ -394,7 +560,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);
@@ -503,7 +669,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-CSNtEnbF.js'); }).then(function (n) { return n.getPropertyData; });
+        const { getPropertyData: getPropertyDataFromDb } = await Promise.resolve().then(function () { return require('./index-C66AfYDG.js'); }).then(function (n) { return n.getPropertyData; });
         const metaRow = await getPropertyDataFromDb({
             propertyName: relationOrImageProperty.propertyName,
             seedLocalId: context.seedLocalId,
@@ -525,14 +691,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 property.getPropertySchema(relationOrImageProperty.modelName, relationOrImageProperty.propertyName);
+        const propertyScope = await main_cjs.getItemModelScope(relationOrImageProperty);
+        let schema = await property.getPropertySchema(relationOrImageProperty.modelName, relationOrImageProperty.propertyName, propertyScope);
         if (!schema && main_cjs.BaseDb.getAppDb()) {
             const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(relationOrImageProperty.modelName));
-            const modelRecords = await main_cjs.BaseDb.getAppDb()
-                .select({ id: main_cjs.models.id })
-                .from(main_cjs.models)
-                .where(drizzleOrm.eq(main_cjs.models.name, normalizedModelName))
-                .limit(1);
+            const modelRecord = await main_cjs.resolveModelRecord(normalizedModelName, propertyScope);
+            const modelRecords = modelRecord ? [modelRecord] : [];
             if (modelRecords.length > 0 && modelRecords[0].id) {
                 const propertyRecords = await main_cjs.BaseDb.getAppDb()
                     .select()
@@ -588,13 +752,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 });
     // Use dynamic import to break circular dependency
-    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-B6jEINjW.js'); });
+    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.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.
@@ -652,7 +818,12 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         ],
     };
     await ensurePropertyDefs(relatedItem);
-    const { itemBasicProperties, itemUploadProperties } = await getSegmentedItemProperties.getSegmentedItemProperties(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);
@@ -672,7 +843,7 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
         if (isStorageTransactionPropertyName(p.propertyName) &&
             !p.propertyDef &&
             relatedItem.modelName) {
-            const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId');
+            const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId', await main_cjs.getItemModelScope(relatedItem));
             if (schema) {
                 p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
             }
@@ -685,6 +856,19 @@ const processRelationOrImageProperty = async (relationOrImageProperty, multiPubl
     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, relatedItem.seedLocalId, ctx, buildOpts);
+}
 async function resolveHtmlPropertySchemaUidByHtmlSeed(item, htmlSeedLocalId, ctx) {
     const want = htmlSeedLocalId.trim();
     for (const p of item.properties) {
@@ -716,13 +900,19 @@ 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-B6jEINjW.js'); });
+    const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.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;
+        }
         const htmlSchemaUid = await resolveHtmlPropertySchemaUidByHtmlSeed(item, row.htmlSeedLocalId, ctx);
         if (!htmlSchemaUid)
             continue;
@@ -777,7 +967,7 @@ async function processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPaylo
             if (isStorageTransactionPropertyName(p.propertyName) &&
                 !p.propertyDef &&
                 relatedItem.modelName) {
-                const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId');
+                const schema = await property.getPropertySchema(relatedItem.modelName, 'storageTransactionId', await main_cjs.getItemModelScope(relatedItem));
                 if (schema) {
                     p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
                 }
@@ -835,13 +1025,14 @@ 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 });
         // Use dynamic import to break circular dependency
-        const getItemMod = await Promise.resolve().then(function () { return require('./getItem-B6jEINjW.js'); });
+        const getItemMod = await Promise.resolve().then(function () { return require('./getItem-DSRtx_68.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 (!main_cjs.isPublishedSeedRef(idStr)) {
@@ -1031,18 +1222,15 @@ 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 !== main_cjs.ZERO_BYTES32;
+    const republishRevokedSeed = hasSeedUid && (await 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');
     }
@@ -1063,15 +1251,15 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         }
     }
     let versionUid = getVersionUid(item);
-    if (versionUid === main_cjs.ZERO_BYTES32 && item.seedUid && item.seedUid !== main_cjs.ZERO_BYTES32) {
-        versionUid = await resolveVersionUid(item.seedLocalId, item.seedUid);
+    if (versionUid === main_cjs.ZERO_BYTES32 && rootSeedUid !== main_cjs.ZERO_BYTES32) {
+        versionUid = await resolveVersionUid(item.seedLocalId, rootSeedUid);
     }
-    if (forceFullSnapshot && item.seedUid && item.seedUid !== main_cjs.ZERO_BYTES32) {
+    if (forceFullSnapshot && hasSeedUid) {
         versionUid = main_cjs.ZERO_BYTES32;
     }
     let itemPublishData = {
         localId: item.seedLocalId,
-        seedUid: item.seedUid || main_cjs.ZERO_BYTES32,
+        seedUid: rootSeedUid,
         seedIsRevocable: true,
         seedSchemaUid: itemSchemaUid,
         versionSchemaUid: main_cjs.VERSION_SCHEMA_UID,
@@ -1093,11 +1281,8 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
         let isRequired = relProp.propertyDef?.required === true;
         if (!isRequired && main_cjs.BaseDb.getAppDb() && item.modelName) {
             const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(item.modelName));
-            const modelRows = await main_cjs.BaseDb.getAppDb()
-                .select({ id: main_cjs.models.id })
-                .from(main_cjs.models)
-                .where(drizzleOrm.eq(main_cjs.models.name, normalizedModelName))
-                .limit(1);
+            const modelRecord = await main_cjs.resolveModelRecord(normalizedModelName, await main_cjs.getItemModelScope(item));
+            const modelRows = modelRecord ? [modelRecord] : [];
             if (modelRows.length > 0) {
                 const propRows = await main_cjs.BaseDb.getAppDb()
                     .select({ required: main_cjs.properties.required, refModelId: main_cjs.properties.refModelId })
@@ -1139,7 +1324,7 @@ const getPublishPayload = async (item, uploadedTransactions, options) => {
     }
     for (const p of itemBasicProperties) {
         if (isStorageTransactionPropertyName(p.propertyName) && !p.propertyDef && item.modelName) {
-            const schema = await property.getPropertySchema(item.modelName, 'storageTransactionId');
+            const schema = await property.getPropertySchema(item.modelName, 'storageTransactionId', await main_cjs.getItemModelScope(item));
             if (schema) {
                 p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
             }
@@ -1165,6 +1350,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);
@@ -1449,4 +1638,4 @@ exports.PublishValidationFailedError = PublishValidationFailedError;
 exports.getPublishPayload = getPublishPayload;
 exports.resolvePublishPayloadValues = resolvePublishPayloadValues;
 exports.validateItemForPublish = validateItemForPublish;
-//# sourceMappingURL=getPublishPayload-D5DhLGvN.js.map
+//# sourceMappingURL=getPublishPayload-D5-dYtNq.js.map