@seedprotocol/sdk 0.7.9-next.1177.ga3e08ed → 0.7.9-next.1306.g4ff6582

package/dist/getPublishPayload-BnIwpwz1.js

@@ -0,0 +1,760 @@
+import { isValidEasAttestationUid, VERSION_SCHEMA_UID, decodeEasNumber, getSchemaUidForSchemaDefinitionFromCache, easName, getEasSchemaUidForSchemaDefinition } from '@seedprotocol/eas';
+import { $ as isNode, Z as ZERO_BYTES32, a0 as INTERNAL_PROPERTY_NAMES, M as ModelPropertyDataTypes, n as normalizeDataType, a1 as defaultAttestationData, v as INTERNAL_DATA_TYPES } from './tabEvents-CaVmngqr.js';
+import { ae as matchMetadataProperty, af as metadataRowsOfProperty, ag as METADATA_LATEST_FIRST_ORDER_SQL, K as isPublishedMetadataRow, ah as getEasSchemaUidForModel, ai as isStorageSeedRef, a8 as listRelationEasPropertyName, a9 as easPropertyNameForPublish, aa as metadataStorageName } from './Item-Bf4kWKpH.js';
+import { or, eq, and, sql } from 'drizzle-orm';
+import { B as BaseDb, m as metadata } from './BaseFileManager-BAlySv8w.js';
+import './errors-DLSoqSHG.js';
+import 'pluralize';
+import { g as getPublishGraph, h as htmlPropertyForHtmlSeed } from './publishGraph-EcB40Uii.js';
+
+const isEmptyValue = (value) => value == null || value === '';
+/**
+ * What publishing a property with an empty value does (ADR 0021). Undefined when there is nothing
+ * to publish: the newest row holds a value, or the property has no live attestation (never
+ * published, or already retracted). The property's rows are those linked by property_id, and rows
+ * with none stored under one of its names.
+ */
+async function getPropertyClear(params) {
+    const { seedLocalId, seedUid, propertyName, propertyId, modelName, dataType, refValueType } = params;
+    if (!seedLocalId && !seedUid)
+        return undefined;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return undefined;
+    // The property's rows by property_id (decision D4), rows with none by name
+    const property = await matchMetadataProperty({ propertyId, propertyName, modelName, seedLocalId, seedUid, dataType, refValueType }, appDb);
+    const seedWhere = seedLocalId && seedUid
+        ? or(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid))
+        : seedLocalId
+            ? eq(metadata.seedLocalId, seedLocalId)
+            : eq(metadata.seedUid, seedUid);
+    const rows = (await appDb
+        .select()
+        .from(metadata)
+        .where(and(metadataRowsOfProperty(property), seedWhere))
+        .orderBy(sql.raw(METADATA_LATEST_FIRST_ORDER_SQL)));
+    const newest = rows[0];
+    if (!newest || !isEmptyValue(newest.propertyValue))
+        return undefined;
+    const live = rows.filter((row) => isValidEasAttestationUid(row.uid) && row.revokedAt == null);
+    if (live.length === 0)
+        return undefined;
+    // `live` is newest first
+    const onVersion = live.filter((row) => row.versionUid === live[0].versionUid);
+    const values = new Set(onVersion.map((row) => row.propertyValue));
+    const retractScope = live.filter((row) => onVersion.includes(row) || values.has(row.propertyValue));
+    return { retract: !!newest.retract && !isPublishedMetadataRow(newest), live, retractScope };
+}
+/** The empty value of an EAS type, or undefined for `bool` and `uint256`, which have none (ADR 0021). */
+function emptyEasValue(easDataType) {
+    if (easDataType === 'string')
+        return '';
+    if (easDataType === 'bytes32')
+        return `0x${'0'.repeat(64)}`;
+    if (easDataType === 'bytes32[]')
+        return [];
+    return undefined;
+}
+/**
+ * The seed's retracted properties that still have attestations to revoke (ADR 0021), with the
+ * attestations publish revokes for each.
+ */
+async function getPendingRetractions(params) {
+    const { seedLocalId, seedUid } = params;
+    if (!seedLocalId && !seedUid)
+        return [];
+    const { getPublishPendingDiff } = await import('./getPublishPendingDiff-D6_-A5ns.js');
+    const { pendingProperties } = await getPublishPendingDiff({
+        seedLocalId: seedLocalId ?? undefined,
+        seedUid: seedUid ?? undefined,
+    });
+    const retractions = [];
+    for (const { propertyName, change } of pendingProperties) {
+        if (change !== 'retracted')
+            continue;
+        const clear = await getPropertyClear({ seedLocalId, seedUid, propertyName });
+        if (!clear?.retract)
+            continue;
+        const attestations = clear.retractScope
+            .filter((row) => row.uid && row.schemaUid)
+            .map((row) => ({ uid: row.uid, schemaUid: row.schemaUid }));
+        if (attestations.length > 0)
+            retractions.push({ propertyName, attestations });
+    }
+    return retractions;
+}
+
+let easSdkPromise;
+/**
+ * Load eas-sdk on first use instead of at SDK import time.
+ *
+ * On Node this loads eas-sdk's CommonJS build. Its ESM build (2.9.1+) does
+ * `import { isEqual } from 'lodash'`, which Node rejects because lodash is
+ * CommonJS, so a static import made `import '@seedprotocol/sdk'` fail unless the
+ * app ran with `--import @seedprotocol/sdk/node-eas-lodash`.
+ *
+ * `process.getBuiltinModule` (Node 20.16+, 22.3+) keeps `node:module` out of the
+ * import graph, so browser bundlers never see it. Bundlers resolve the
+ * `import()` branch, and handle lodash there themselves.
+ */
+function loadEasSdk() {
+    if (!easSdkPromise) {
+        easSdkPromise = (async () => {
+            if (isNode() && typeof document === 'undefined' && typeof process.getBuiltinModule === 'function') {
+                try {
+                    const { createRequire } = process.getBuiltinModule('node:module');
+                    return createRequire(import.meta.url)('@ethereum-attestation-service/eas-sdk');
+                }
+                catch {
+                    // e.g. import.meta.url is not a file: URL (bundled renderer). Fall through.
+                }
+            }
+            return import('@ethereum-attestation-service/eas-sdk');
+        })();
+        easSdkPromise.catch(() => {
+            easSdkPromise = undefined;
+        });
+    }
+    return easSdkPromise;
+}
+
+/** UTF-8 string to 0x-prefixed bytes32 hex (right-padded with zeros). */
+function encodeBytes32String(value) {
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.length > 32) {
+        throw new Error(`encodeBytes32String: value exceeds 32 bytes (${bytes.length})`);
+    }
+    const hex = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return `0x${hex.padEnd(64, '0')}`;
+}
+
+/** 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 matchesDataType = (actual, expected) => normalizeDataType(actual) === expected;
+/**
+ * An EAS uid (0x + 64 hex), as opposed to a local id. A "0x" prefix alone doesn't tell them apart:
+ * local ids are random alphanumerics, and about 1 in 3,844 starts with "0x".
+ */
+function isUidRef(ref) {
+    return ref.length === 66 && ref.startsWith('0x');
+}
+function addValidationError(ctx, message, field, code = 'publish_validation') {
+    if (ctx.errors.some((e) => e.message === message && e.field === (field ?? '')))
+        return;
+    ctx.errors.push({ field: field ?? '', message, code });
+}
+/** Current uid for a ref to a live published seed, else the ref itself. */
+const currentRelatedRef = (ctx, ref) => ctx.graph.relatedRefUids.get(ref.trim()) ?? ref;
+const uploadedTxFor = (ctx, seedLocalId) => ctx.uploadedTransactions.find((u) => u.seedLocalId?.trim() === seedLocalId);
+/** The EAS schema a property attests under. Reports an error and returns null when there is none. */
+const getPropertyData = async (property, ctx) => {
+    const { key, definition } = property;
+    const rawDataType = definition.dataType;
+    const dataType = rawDataType ? normalizeDataType(String(rawDataType)) : undefined;
+    const easDataType = dataType ? INTERNAL_DATA_TYPES[dataType]?.eas : undefined;
+    if (!easDataType) {
+        addValidationError(ctx, `Unknown or unsupported property data type "${rawDataType ?? 'undefined'}" for property: ${key}. Supported types: ${Object.keys(INTERNAL_DATA_TYPES).join(', ')}.`, key);
+        return null;
+    }
+    // ADR 0008: list relations publish under their storage name (authors → author_identity_ids),
+    // single relations under their schema key (author), never the local authorId.
+    const listRelationName = listRelationEasPropertyName(key, definition);
+    const propertyNameForSchema = easPropertyNameForPublish(key, definition);
+    const schemaDef = `${easDataType} ${propertyNameForSchema}`;
+    // The UID ensureEasSchemasForItem resolved for this exact definition comes first. A row's
+    // schemaUid was looked up under the property's own name, which matches any type: Optimism
+    // Sepolia has `bytes32 storage_transaction_id` beside `string storage_transaction_id`, and
+    // attesting a string under the bytes32 one reads back as 0x…20. Trust the row's only when
+    // that name is the one published (not for a list relation, or a single relation stored as authorId).
+    const storageName = metadataStorageName(key, definition);
+    let schemaUid = getSchemaUidForSchemaDefinitionFromCache(schemaDef) ??
+        (!listRelationName && easName(storageName) === propertyNameForSchema ? property.row?.schemaUid ?? undefined : undefined);
+    if (!schemaUid) {
+        schemaUid = await getEasSchemaUidForSchemaDefinition({ schemaText: schemaDef });
+    }
+    if (!schemaUid) {
+        addValidationError(ctx, `EAS schema not found for "${schemaDef}" (property: ${key}). Register it before publishing (ensureEasSchemasForItem).`, key, 'publish_schema_not_found');
+        return null;
+    }
+    return { schemaUid, easDataType, schemaDef, propertyNameForSchema };
+};
+/** The label a required-value error uses for a relation or storage-seed property. */
+function refTypeLabel(definition) {
+    for (const [type, label] of [
+        [ModelPropertyDataTypes.File, 'file'],
+        [ModelPropertyDataTypes.Image, 'image'],
+        [ModelPropertyDataTypes.Html, 'html'],
+        [ModelPropertyDataTypes.Json, 'json'],
+    ]) {
+        if (matchesDataType(definition.dataType, type) || matchesDataType(definition.refValueType, type))
+            return label;
+    }
+    return 'relation';
+}
+/** Required relation and storage-seed properties need a value pointing at an item. */
+function checkRequiredRef(node, property, ctx) {
+    const { key, definition } = property;
+    if (definition.required !== true)
+        return;
+    const value = property.row?.propertyValue;
+    const refLabel = definition.ref ?? definition.refModelName ?? 'related';
+    if (value == null || value.trim() === '') {
+        addValidationError(ctx, `Required ${refTypeLabel(definition)} ${key} has no value. A value pointing to a valid ${refLabel} item is required to publish.`, key);
+        return;
+    }
+    for (const broken of ctx.graph.brokenRefs) {
+        if (broken.seedLocalId !== node.seedLocalId || broken.propertyKey !== key || broken.list)
+            continue;
+        addValidationError(ctx, broken.reason === 'invalid'
+            ? `Required relation ${key} has invalid value: ${JSON.stringify(value)}. ` +
+                `Value must be a valid seed reference (localId or uid) pointing to a ${refLabel} item.`
+            : `No related item found for required relation: ${key}. Value: ${JSON.stringify(value)} (seedLocalId/seedUid). ` +
+                `The related item may be missing, in a different database, or the reference may be broken.`, key);
+    }
+}
+/** A Boolean row value as stored ("true"/"false", "1"/"0"). */
+const booleanFromRow = (value) => value === 'true' || value === '1' ? true : value === 'false' || value === '0' ? false : value;
+/**
+ * The attestation of one property of `node`, or undefined when the publish leaves it out (no
+ * value, already attested in patch mode, deferred, invalid: the last reports an error).
+ */
+async function attestProperty(node, property, versionUid, ctx) {
+    const { key, definition, row } = property;
+    const forceFullSnapshot = ctx.graph.forceFullSnapshot;
+    if (INTERNAL_PROPERTY_NAMES.includes(key) || property.deferred)
+        return undefined;
+    const isFileImageHtml = matchesDataType(definition.dataType, ModelPropertyDataTypes.File) ||
+        matchesDataType(definition.dataType, ModelPropertyDataTypes.Image) ||
+        matchesDataType(definition.dataType, ModelPropertyDataTypes.Html);
+    const isRef = property.kind === 'relation' || property.kind === 'storageSeed';
+    const isStorageTransaction = property.kind === 'storageTransaction';
+    // The storage transaction slot attests this publish's upload of the node's file(s).
+    const uploaded = isStorageTransaction ? uploadedTxFor(ctx, node.seedLocalId) : undefined;
+    if (isStorageTransaction && !uploaded)
+        return undefined;
+    let value = uploaded ? uploaded.txId : row?.propertyValue;
+    // 0 and false are values (ADR 0010). An empty value publishes only as a removal of a value
+    // attested before (ADR 0021); a retraction attests nothing (publish revokes instead).
+    let isRemoval = false;
+    if (value == null || value === '') {
+        if (property.uid && !forceFullSnapshot)
+            return undefined;
+        const clear = await getPropertyClear({
+            seedLocalId: node.seedLocalId,
+            seedUid: node.seedUid,
+            propertyId: definition._dbId,
+            modelName: node.modelName,
+            propertyName: key,
+            dataType: definition.dataType,
+            refValueType: definition.refValueType,
+        });
+        if (!clear || clear.retract)
+            return undefined;
+        isRemoval = true;
+    }
+    // Patch mode skips properties that already have an EAS uid, except a storage transaction this
+    // publish uploaded.
+    if (!isRemoval && property.uid && !forceFullSnapshot && !uploaded)
+        return undefined;
+    // File/Image/Html values must be a storage seed id by now. Raw content means the property's
+    // save pipeline never ran or failed (e.g. createNewItem with raw html), so it was never uploaded.
+    if (!isRemoval && isFileImageHtml && typeof value === 'string' && !isStorageSeedRef(value.trim())) {
+        addValidationError(ctx, `Invalid value for property: ${key}. Expected a storage seed id ` +
+            `(${normalizeDataType(definition.dataType)} content must be saved through the property before publishing), ` +
+            `got ${value.length > 40 ? `${value.slice(0, 40)}…` : value}.`, key, 'publish_storage_value_not_saved');
+        return undefined;
+    }
+    const propertyData = await getPropertyData(property, ctx);
+    if (!propertyData)
+        return undefined;
+    const { schemaUid, easDataType, schemaDef, propertyNameForSchema } = propertyData;
+    const isList = schemaDef.startsWith('bytes32[]');
+    let rawListIdsForResolve;
+    if (isRemoval) {
+        const empty = emptyEasValue(easDataType);
+        if (empty === undefined) {
+            addValidationError(ctx, `${key} can't be published empty: ${definition.dataType ?? easDataType} properties have no empty value. Clear it with clear({ retract: true }).`, key, 'publish_clear_unsupported');
+            return undefined;
+        }
+        value = empty;
+    }
+    else {
+        if (typeof value === 'string' && isRef)
+            value = currentRelatedRef(ctx, value.trim());
+        if (isList && typeof value === 'string') {
+            const text = value.trim();
+            if (text.startsWith('[')) {
+                try {
+                    value = JSON.parse(text);
+                }
+                catch {
+                    // reported below
+                }
+            }
+            else if (text.includes(',')) {
+                // Legacy comma-separated ids (pre-JSON List storage)
+                value = text.split(',').map((s) => s.trim()).filter(Boolean);
+            }
+        }
+        if (isList && !Array.isArray(value)) {
+            addValidationError(ctx, `Invalid value for property: ${key}. Expected an array of bytes32, got ${value}.`, key);
+            return undefined;
+        }
+        if (easDataType === 'bool' && typeof value === 'string')
+            value = booleanFromRow(value.trim());
+        // Validate against property validation rules (enum, pattern, minLength, maxLength) before encoding
+        if (definition.validation) {
+            const { SchemaValidationService } = await import('./SchemaValidationService-CnmKyzR-.js');
+            const result = new SchemaValidationService().validatePropertyValue(value, normalizeDataType(definition.dataType), definition.validation, definition.refValueType ? normalizeDataType(definition.refValueType) : undefined);
+            if (!result.isValid && result.errors.length > 0) {
+                const firstError = result.errors[0];
+                addValidationError(ctx, firstError.message, key, firstError.code ?? 'publish_validation');
+                return undefined;
+            }
+        }
+        if (isList) {
+            const encoded = [];
+            const rawIds = [];
+            for (const member of value) {
+                const id = typeof member === 'string' ? member.trim() : '';
+                if (!id)
+                    continue;
+                const ref = currentRelatedRef(ctx, id);
+                rawIds.push(ref);
+                encoded.push(isUidRef(ref) ? ref : encodeBytes32String(ref));
+            }
+            value = encoded;
+            if (rawIds.some((id) => !isUidRef(id)))
+                rawListIdsForResolve = rawIds;
+        }
+        // uint256 (Date) must be numeric/BigInt; normalize ISO strings to Unix seconds
+        if (easDataType === 'uint256' && (typeof value === 'string' || value instanceof Date)) {
+            const ms = value instanceof Date ? value.getTime() : /^\d+$/.test(value) ? Number(value) : new Date(value).getTime();
+            value = BigInt(Math.floor(ms / 1000));
+        }
+        // ADR 0010: Number attests as its decimal string, in the form readers decode it to.
+        if (matchesDataType(definition.dataType, ModelPropertyDataTypes.Number)) {
+            const decimal = decodeEasNumber(value);
+            if (decimal === undefined) {
+                addValidationError(ctx, `Invalid value for property: ${key}. Expected a finite number, got ${JSON.stringify(value)}.`, key, 'publish_invalid_number');
+                return undefined;
+            }
+            value = decimal;
+        }
+    }
+    let encodedData;
+    try {
+        const { SchemaEncoder } = await loadEasSdk();
+        encodedData = new SchemaEncoder(schemaDef).encodeData([
+            { name: propertyNameForSchema, type: easDataType, value: value },
+        ]);
+    }
+    catch (encodeErr) {
+        addValidationError(ctx, `Failed to encode property ${key}: ${encodeErr instanceof Error ? encodeErr.message : String(encodeErr)}`, key);
+        return undefined;
+    }
+    const attestation = {
+        schema: schemaUid,
+        data: [
+            {
+                ...defaultAttestationData,
+                // The storage transaction references the Version attestation (contract may use when supported)
+                refUID: isStorageTransaction ? versionUid : defaultAttestationData.refUID,
+                data: encodedData,
+            },
+        ],
+        _propertyName: key,
+        ...(row?.localId ? { _metadataLocalId: row.localId } : {}),
+        ...(uploaded && uploaded.txId !== row?.propertyValue ? { _attestedValue: uploaded.txId } : {}),
+    };
+    // Refs to seeds of this publish by local id: resolution hints for resolvePublishPayloadValues
+    if (typeof value === 'string' &&
+        !isUidRef(value) &&
+        /^[a-zA-Z0-9_-]{10,21}$/.test(value.trim()) &&
+        (easDataType === 'bytes32' || easDataType === 'string')) {
+        attestation._propertyNameForSchema = propertyNameForSchema;
+        attestation._schemaDef = schemaDef;
+        attestation._unresolvedValue = value.trim();
+        attestation._easDataType = easDataType;
+    }
+    if (rawListIdsForResolve?.length) {
+        attestation._propertyNameForSchema = propertyNameForSchema;
+        attestation._schemaDef = schemaDef;
+        attestation._easDataType = 'bytes32[]';
+        attestation._rawListIdsForResolve = rawListIdsForResolve;
+    }
+    return attestation;
+}
+/** The order a node's properties attest in: basic values, its upload, refs, lists. */
+const ATTEST_ORDER = ['basic', 'storageTransaction', 'relation', 'storageSeed', 'list'];
+/** One node's request: its seed, version and property attestations, and the parent properties its seed uid fills. */
+async function buildRequest(node, ctx) {
+    const { graph } = ctx;
+    const isRoot = node.kind === 'root';
+    // A storage seed or an embedded image attests its own basic properties only.
+    const full = isRoot || node.kind === 'draft';
+    const reportField = node.links[0]?.propertyKey;
+    let seedSchemaUid = isRoot ? node.seedSchemaUid : undefined;
+    seedSchemaUid ?? (seedSchemaUid = (await getEasSchemaUidForModel(node.modelName)) ?? undefined);
+    if (!seedSchemaUid)
+        addValidationError(ctx, `Schema UID not found for model: ${node.modelName}`, isRoot ? undefined : reportField);
+    let versionUid = node.version.uid ?? (node.newSeed ? undefined : node.version.publishedUid) ?? ZERO_BYTES32;
+    if (isRoot && graph.forceFullSnapshot && node.seedUid)
+        versionUid = ZERO_BYTES32;
+    const versionLocalId = versionUid === ZERO_BYTES32 && !node.version.uid ? node.version.localId : undefined;
+    const request = {
+        localId: node.seedLocalId,
+        ...(versionLocalId ? { versionLocalId } : {}),
+        seedIsRevocable: true,
+        seedSchemaUid: seedSchemaUid ?? ZERO_BYTES32,
+        seedUid: node.newSeed || !node.seedUid ? ZERO_BYTES32 : node.seedUid,
+        versionSchemaUid: VERSION_SCHEMA_UID,
+        versionUid,
+        listOfAttestations: [],
+        propertiesToUpdate: [],
+    };
+    for (const kind of ATTEST_ORDER) {
+        for (const property of node.properties) {
+            if (property.kind !== kind)
+                continue;
+            if (!full && kind !== 'basic' && kind !== 'storageTransaction')
+                continue;
+            if (full && (kind === 'relation' || kind === 'storageSeed'))
+                checkRequiredRef(node, property, ctx);
+            const attestation = await attestProperty(node, property, versionUid, ctx);
+            if (attestation)
+                request.listOfAttestations.push(attestation);
+        }
+    }
+    // Each property this seed's uid fills: the contract writes the uid into that attestation.
+    for (const { seedLocalId, propertyKey } of node.links) {
+        const owner = graph.nodes.find((n) => n.seedLocalId === seedLocalId);
+        const property = owner?.properties.find((p) => p.key === propertyKey);
+        if (!property)
+            continue;
+        const propertySchemaUid = (await getPropertyData(property, ctx))?.schemaUid;
+        if (!propertySchemaUid)
+            continue;
+        if (!request.propertiesToUpdate.some((u) => u.publishLocalId === seedLocalId && u.propertySchemaUid.toLowerCase() === propertySchemaUid.toLowerCase())) {
+            request.propertiesToUpdate.push({ publishLocalId: seedLocalId, propertySchemaUid });
+        }
+    }
+    return request;
+}
+/**
+ * Embedded image rows must still name an Html value of their owner, with a schema to attest under.
+ * 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.
+ */
+async function checkEmbeddedImages(ctx) {
+    const { graph } = ctx;
+    for (const owner of graph.nodes) {
+        for (const row of owner.embeddedImages) {
+            const imageNode = graph.nodes.find((n) => n.seedLocalId === row.imageSeedLocalId && n.kind === 'embeddedImage');
+            const missing = graph.missingEmbeddedImages.some((m) => m.imageSeedLocalId === row.imageSeedLocalId);
+            if (!imageNode && !missing)
+                continue;
+            const html = htmlPropertyForHtmlSeed(owner, row.htmlSeedLocalId);
+            if (!html) {
+                addValidationError(ctx, `Could not find Html property for embedded image rewrite (html seed ${row.htmlSeedLocalId.trim()}).`, 'html', 'html_embed_schema');
+                continue;
+            }
+            if (!(await getPropertyData(html, ctx)))
+                continue;
+            if (missing) {
+                addValidationError(ctx, `Embedded Image item not found for seed ${row.imageSeedLocalId}.`, 'html', 'html_embed_image_missing');
+            }
+        }
+    }
+}
+const getPublishPayload = async (item, uploadedTransactions, options) => {
+    const publishMode = options?.publishMode ?? 'patch';
+    const graph = await getPublishGraph(item, { publishMode });
+    const ctx = { graph, errors: [], uploadedTransactions };
+    if (publishMode === 'new_version' && !graph.root.seedUid) {
+        addValidationError(ctx, '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 = [];
+    for (const node of graph.nodes)
+        multiPublishPayload.push(await buildRequest(node, ctx));
+    await checkEmbeddedImages(ctx);
+    // A request whose seed fills another request's property (propertiesToUpdate) publishes first, and a
+    // request encoding another's local id publishes after it.
+    multiPublishPayload = orderPayloadByDependencies(multiPublishPayload);
+    if (publishMode === 'new_version') {
+        const rootPayload = multiPublishPayload.find((p) => p.localId === graph.root.seedLocalId);
+        if (!rootPayload?.listOfAttestations.length) {
+            addValidationError(ctx, 'Publishing as a new version requires at least one property attestation for the item. ' +
+                'Ensure required fields have values and that publishable properties are present.', 'listOfAttestations', 'publish_new_version_empty_snapshot');
+        }
+    }
+    // Stop before anything is uploaded or attested: the payload would attest revoked seed uids.
+    if (graph.unpublishedRelatedItems.length) {
+        throw new RelatedItemUnpublishedError(graph.unpublishedRelatedItems, ctx.errors);
+    }
+    if (ctx.errors.length > 0) {
+        const combinedMessage = ctx.errors.map((e) => e.message).join('\n');
+        throw new PublishValidationFailedError(`Validation failed (${ctx.errors.length} error${ctx.errors.length === 1 ? '' : 's'}):\n${combinedMessage}`, ctx.errors);
+    }
+    return multiPublishPayload;
+};
+/**
+ * Validates an item for publishing without performing Arweave or EAS work.
+ * Use in the checking step to fail fast before creating transactions.
+ * Pass empty array for uploadedTransactions when validating before Arweave upload.
+ */
+const validateItemForPublish = async (item, uploadedTransactions = [], options) => {
+    try {
+        await getPublishPayload(item, uploadedTransactions, options);
+        return { isValid: true, errors: [] };
+    }
+    catch (err) {
+        if (err instanceof PublishValidationFailedError) {
+            return { isValid: false, errors: err.validationErrors };
+        }
+        throw err;
+    }
+};
+/**
+ * LocalIds in this batch referenced by attestations (bytes32 / bytes32[]) that must publish before this request.
+ */
+function collectAttestationLocalRefIds(req, allLocalIds) {
+    const refs = [];
+    for (const att of req.listOfAttestations) {
+        if (att._unresolvedValue && allLocalIds.has(att._unresolvedValue))
+            refs.push(att._unresolvedValue);
+        for (const id of att._rawListIdsForResolve ?? []) {
+            const t = id != null ? String(id).trim() : '';
+            if (t && allLocalIds.has(t))
+                refs.push(t);
+        }
+    }
+    return refs;
+}
+/**
+ * Topological sort (Kahn): edge `from → to` means `from` must publish before `to`.
+ * - propertiesToUpdate: updater before updatee (contract injection).
+ * - _unresolvedValue / _rawListIdsForResolve: referenced seed before request that encodes the ref.
+ * Ties keep the input order (the graph's finish order).
+ */
+function orderPayloadByDependencies(payload) {
+    if (payload.length <= 1)
+        return payload;
+    const byLocalId = new Map();
+    const indexOrder = new Map();
+    payload.forEach((p, i) => {
+        byLocalId.set(p.localId, p);
+        indexOrder.set(p.localId, i);
+    });
+    const allIds = new Set(byLocalId.keys());
+    const indegree = new Map([...allIds].map((id) => [id, 0]));
+    const adj = new Map();
+    const addEdge = (from, to) => {
+        if (from === to || !allIds.has(from) || !allIds.has(to))
+            return;
+        if (!adj.has(from))
+            adj.set(from, new Set());
+        const set = adj.get(from);
+        if (set.has(to))
+            return;
+        set.add(to);
+        indegree.set(to, (indegree.get(to) ?? 0) + 1);
+    };
+    for (const p of payload) {
+        for (const u of p.propertiesToUpdate)
+            addEdge(p.localId, u.publishLocalId);
+        for (const refId of collectAttestationLocalRefIds(p, allIds))
+            addEdge(refId, p.localId);
+    }
+    const byInputOrder = (a, b) => (indexOrder.get(a) ?? 0) - (indexOrder.get(b) ?? 0);
+    const queue = [...allIds].filter((id) => (indegree.get(id) ?? 0) === 0).sort(byInputOrder);
+    const result = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        result.push(byLocalId.get(id));
+        for (const to of adj.get(id) ?? []) {
+            const next = (indegree.get(to) ?? 0) - 1;
+            indegree.set(to, next);
+            if (next === 0) {
+                queue.push(to);
+                queue.sort(byInputOrder);
+            }
+        }
+    }
+    if (result.length !== payload.length) {
+        const seen = new Set(result.map((r) => r.localId));
+        for (const p of payload)
+            if (!seen.has(p.localId))
+                result.push(p);
+    }
+    return result;
+}
+/** Normalize attestation UID to 32-byte hex for SchemaEncoder bytes32 fields. */
+function padUidForBytes32Schema(uid) {
+    const t = uid.trim();
+    if (!t.startsWith('0x'))
+        return uid;
+    const hex = t.slice(2).replace(/[^0-9a-fA-F]/g, '');
+    if (hex.length === 0)
+        return uid;
+    return ('0x' + hex.padStart(64, '0').slice(-64)).toLowerCase();
+}
+/**
+ * Resolves relation/image property values (seedLocalId) to attestation uids after dependent seeds are published.
+ * Call after each payload is published, passing the returned attestation uid for that seed's localId.
+ * Returns an updated multiPayload with re-encoded attestations where resolution was applied.
+ */
+const resolvePublishPayloadValues = async (multiPayload, resolvedUids) => {
+    if (Object.keys(resolvedUids).length === 0) {
+        return multiPayload;
+    }
+    const { SchemaEncoder } = await loadEasSdk();
+    const result = [];
+    for (const payload of multiPayload) {
+        const updatedAttestations = [];
+        for (const attestation of payload.listOfAttestations) {
+            const entry = attestation;
+            const rawList = entry._rawListIdsForResolve;
+            if (rawList &&
+                rawList.length > 0 &&
+                entry._schemaDef &&
+                (entry._propertyNameForSchema || entry._propertyName)) {
+                const fieldName = entry._propertyNameForSchema ?? easName(entry._propertyName);
+                const resolvedValues = [];
+                let allSlotsResolved = true;
+                for (const id of rawList) {
+                    const trimmed = id.trim();
+                    if (isUidRef(trimmed)) {
+                        resolvedValues.push(padUidForBytes32Schema(trimmed));
+                        continue;
+                    }
+                    const r = resolvedUids[trimmed];
+                    if (r) {
+                        resolvedValues.push(padUidForBytes32Schema(r));
+                        continue;
+                    }
+                    allSlotsResolved = false;
+                    break;
+                }
+                // Do not encode or clear hints until every slot has a real uid — otherwise sequential
+                // publish burns encodeBytes32String(localId) into data and drops _rawListIdsForResolve.
+                if (!allSlotsResolved) {
+                    updatedAttestations.push({
+                        ...entry,
+                        data: Array.isArray(entry.data) ? entry.data : [entry.data],
+                    });
+                    continue;
+                }
+                const dataEncoder = new SchemaEncoder(entry._schemaDef);
+                const encodedData = dataEncoder.encodeData([
+                    {
+                        name: fieldName,
+                        type: 'bytes32[]',
+                        value: resolvedValues,
+                    },
+                ]);
+                const baseData = Array.isArray(entry.data) ? entry.data[0] : entry.data;
+                updatedAttestations.push({
+                    ...entry,
+                    data: [
+                        {
+                            ...baseData,
+                            data: encodedData,
+                        },
+                    ],
+                    _rawListIdsForResolve: undefined,
+                    _easDataType: undefined,
+                });
+                continue;
+            }
+            const resolvedUid = entry._unresolvedValue && resolvedUids[entry._unresolvedValue];
+            const easType = entry._easDataType || 'bytes32';
+            if (resolvedUid && entry._schemaDef && (entry._propertyNameForSchema || entry._propertyName)) {
+                const fieldName = entry._propertyNameForSchema ?? easName(entry._propertyName);
+                const valueForEncode = easType === 'bytes32' ? padUidForBytes32Schema(resolvedUid) : resolvedUid;
+                const dataEncoder = new SchemaEncoder(entry._schemaDef);
+                const encodedData = dataEncoder.encodeData([
+                    {
+                        name: fieldName,
+                        type: easType,
+                        value: valueForEncode,
+                    },
+                ]);
+                const baseData = Array.isArray(entry.data) ? entry.data[0] : entry.data;
+                updatedAttestations.push({
+                    ...entry,
+                    data: [
+                        {
+                            ...baseData,
+                            data: encodedData,
+                        },
+                    ],
+                    _unresolvedValue: undefined,
+                });
+            }
+            else {
+                const normalizedEntry = {
+                    ...entry,
+                    data: Array.isArray(entry.data) ? entry.data : [entry.data],
+                };
+                updatedAttestations.push(normalizedEntry);
+            }
+        }
+        result.push({
+            ...payload,
+            listOfAttestations: updatedAttestations,
+        });
+    }
+    return result;
+};
+
+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, getPendingRetractions as b, getPublishPayload$1 as c, getPropertyClear as g, resolvePublishPayloadValues as r, validateItemForPublish as v };
+//# sourceMappingURL=getPublishPayload-BnIwpwz1.js.map