@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/getPublishPayload-pbin4lk8.js

@@ -1,1736 +0,0 @@
-import { isValidEasAttestationUid, VERSION_SCHEMA_UID, easName, decodeEasNumber, getSchemaUidForSchemaDefinitionFromCache, getEasSchemaUidForSchemaDefinition } from '@seedprotocol/eas';
-import { L as BaseDb, ab as getMetadataPropertyNamesForQuery, m as metadata, ac as isNode, ad as ZERO_BYTES32, R as resolveModelRecord, ae as getItemModelScope, E as properties, p as models, M as ModelPropertyDataTypes, r as resolveSeedIdsFromRefString, q as normalizeRelationPropertyValue, l as isPublishedSeedRef, x as htmlEmbeddedImageCoPublish, k as getCorrectId, af as INTERNAL_PROPERTY_NAMES, ag as isStorageSeedRef, n as normalizeDataType, ah as defaultAttestationData, $ as INTERNAL_DATA_TYPES, a7 as listRelationEasPropertyName, a8 as easPropertyNameForPublish } from './index-rOTW-2QZ.js';
-import { I as ItemLoads, 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-DBWAN72w.js';
-import { M as METADATA_LATEST_FIRST_ORDER_SQL, z as isPublishedMetadataRow, K as getEasSchemaUidForModel, A as getLatestPublishedVersionRow, L as parseListPropertyValueFromStorage } from './Item-CG5IhPtL.js';
-import { or, eq, and, sql } from 'drizzle-orm';
-import { getPropertySchema } from './property-C85DCD7K.js';
-import { modelPropertiesToObject } from './model-oHA3YhOd.js';
-import { upperFirst, camelCase } from 'lodash-es';
-import './errors-CS3nDpUU.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). Rows of every name the property is stored under count.
- */
-async function getPropertyClear(params) {
-    const { seedLocalId, seedUid, propertyName, dataType, refValueType } = params;
-    if (!seedLocalId && !seedUid)
-        return undefined;
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return undefined;
-    const names = getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType);
-    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(or(...names.map((name) => eq(metadata.propertyName, name))), 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-ByIaPvCn.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;
-    }
-}
-
-/** 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;
-}
-/**
- * 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') {
-    // 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 ?? '')))
-        return;
-    ctx.errors.push({ field: field ?? '', message, code });
-}
-/** File/Image/Html value is raw content instead of a storage seed id, so it was never saved/uploaded. */
-function addStorageValueNotSavedError(ctx, propertyName, dataType, value) {
-    addValidationError(ctx, `Invalid value for property: ${propertyName}. Expected a storage seed id ` +
-        `(${normalizeDataType(dataType)} content must be saved through the property before publishing), ` +
-        `got ${value.length > 40 ? `${value.slice(0, 40)}…` : value}.`, propertyName, 'publish_storage_value_not_saved');
-}
-function isStorageTransactionPropertyName(name) {
-    return name === 'storageTransactionId' || name === 'storage_transaction_id';
-}
-/**
- * Segmentation or naming variants can leave two rows for the same logical field; keep one
- * resolved slot so processBasicProperties emits a single storage tx attestation.
- */
-function replaceStorageTransactionInBasicProperties(itemBasicProperties, resolved) {
-    const filtered = itemBasicProperties.filter((p) => !isStorageTransactionPropertyName(p.propertyName));
-    itemBasicProperties.length = 0;
-    itemBasicProperties.push(...filtered, resolved);
-}
-/** If multiple storageTransactionId ItemProperty rows slipped in, keep one (last wins). */
-function dedupeOneStorageTransactionPropertyInList(itemBasicProperties) {
-    const nonStorage = [];
-    const storage = [];
-    for (const p of itemBasicProperties) {
-        if (isStorageTransactionPropertyName(p.propertyName)) {
-            storage.push(p);
-        }
-        else {
-            nonStorage.push(p);
-        }
-    }
-    if (storage.length <= 1)
-        return;
-    itemBasicProperties.length = 0;
-    itemBasicProperties.push(...nonStorage, storage[storage.length - 1]);
-}
-/**
- * Two relation/image props (e.g. content + featureImage) can reference the same File/Image seed.
- * Only one child PublishPayload should exist per related seedLocalId; merge propertiesToUpdate instead.
- */
-function mergeChildPublishPayloadIfDuplicateInBatch(multiPublishPayload, relatedSeedLocalId, publishLocalId, propertySchemaUid) {
-    const existing = multiPublishPayload.find((p) => p.localId === relatedSeedLocalId);
-    if (!existing)
-        return false;
-    const pts = existing.propertiesToUpdate ?? [];
-    const already = pts.some((e) => e.publishLocalId === publishLocalId &&
-        String(e.propertySchemaUid ?? '').toLowerCase() ===
-            String(propertySchemaUid ?? '').toLowerCase());
-    if (!already) {
-        pts.push({ publishLocalId, propertySchemaUid });
-    }
-    return true;
-}
-const getVersionUid = (item) => {
-    const latestVersion = item.latestVersionUid;
-    if (latestVersion && typeof latestVersion === 'object' && latestVersion.uid) {
-        const u = latestVersion.uid;
-        return isValidEasAttestationUid(u) ? u : ZERO_BYTES32;
-    }
-    if (latestVersion && typeof latestVersion === 'string') {
-        return isValidEasAttestationUid(latestVersion) ? latestVersion : ZERO_BYTES32;
-    }
-    return ZERO_BYTES32;
-};
-/**
- * Resolve versionUid when item.latestVersionUid is empty but item has been published (has seedUid).
- * Tries DB first, then EAS. If the local versions row still has a placeholder uid after publish,
- * EAS fallback queries attestations where refUID=seedUid (Version attestations).
- */
-async function resolveVersionUid(seedLocalId, seedUid) {
-    if (!seedLocalId || !seedUid || seedUid === ZERO_BYTES32)
-        return ZERO_BYTES32;
-    const published = await getLatestPublishedVersionRow(seedLocalId);
-    if (published?.uid)
-        return published.uid;
-    try {
-        const { getItemVersionsFromEas } = await import('./eas-B5VJolSj.js');
-        const attestations = await getItemVersionsFromEas({ seedUids: [seedUid] });
-        const latest = attestations?.[0];
-        if (latest?.id)
-            return latest.id;
-    }
-    catch {
-        // EAS client may not be initialized or network error
-    }
-    return ZERO_BYTES32;
-}
-const getPropertyData = async (itemProperty, ctx) => {
-    const rawDataType = itemProperty.propertyDef?.dataType;
-    const dataType = rawDataType ? normalizeDataType(String(rawDataType)) : undefined;
-    const entry = dataType
-        ? INTERNAL_DATA_TYPES[dataType]
-        : undefined;
-    const easDataType = entry?.eas;
-    if (!easDataType) {
-        if (ctx) {
-            addValidationError(ctx, `Unknown or unsupported property data type "${rawDataType ?? 'undefined'}" for property: ${itemProperty.propertyName}. Supported types: ${Object.keys(INTERNAL_DATA_TYPES).join(', ')}.`, itemProperty.propertyName);
-        }
-        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 propertyDef = itemProperty.propertyDef;
-    const listRelationName = listRelationEasPropertyName(itemProperty.propertyName, propertyDef);
-    const propertyNameForSchema = easPropertyNameForPublish(itemProperty.propertyName, propertyDef);
-    const schemaDef = `${easDataType} ${propertyNameForSchema}`;
-    // The UID ensureEasSchemasForItem resolved for this exact definition comes first. A cached
-    // 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 cached one only when
-    // that name is the one published (not for a list relation, or a single relation stored as authorId).
-    const storageName = itemProperty.storagePropertyName ||
-        itemProperty.propertyName;
-    let schemaUid = getSchemaUidForSchemaDefinitionFromCache(schemaDef) ??
-        (!listRelationName && easName(storageName) === propertyNameForSchema ? itemProperty.schemaUid : undefined);
-    if (!schemaUid) {
-        schemaUid = await getEasSchemaUidForSchemaDefinition({ schemaText: schemaDef });
-    }
-    if (!schemaUid) {
-        if (ctx) {
-            addValidationError(ctx, `EAS schema not found for "${schemaDef}" (property: ${itemProperty.propertyName}). Register it before publishing (ensureEasSchemasForItem).`, itemProperty.propertyName, 'publish_schema_not_found');
-        }
-        return null;
-    }
-    return {
-        schemaUid,
-        easDataType,
-        schemaDef,
-        propertyNameForSchema,
-    };
-};
-/** Resolve propertyDef from Model for properties that lack it (e.g. cached instances
- * created before loadOrCreateProperty was fixed). Ensures both new and existing items get property attestations.
- * Also ensures Relation/Image properties have required from schema when missing (for publish validation). */
-const ensurePropertyDefs = async (targetItem) => {
-    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, targetScope);
-            if (!schema) {
-                try {
-                    const _mod_0 = await import('./errors-CS3nDpUU.js');
-                    const _ns_0 = _mod_0.i;
-                    const { Model } = _ns_0;
-                    const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
-                    let model = Model.resolve(normalizedModelName, targetScope);
-                    if (!model?.properties?.length && !targetScope.modelFileId) {
-                        model = Model.findByModelType(easName(targetItem.modelName));
-                    }
-                    const schemaKeys = [];
-                    if (model?.properties?.length) {
-                        const schemas = modelPropertiesToObject(model.properties);
-                        schemaKeys.push(...Object.keys(schemas));
-                        schema = schemas[itemProperty.propertyName];
-                    }
-                }
-                catch {
-                    schema = undefined;
-                }
-            }
-            if (!schema) {
-                const db = BaseDb.getAppDb();
-                if (db) {
-                    try {
-                        const normalizedModelName = upperFirst(camelCase(targetItem.modelName));
-                        const modelRecord = await resolveModelRecord(normalizedModelName, targetScope, db);
-                        const modelRecords = modelRecord ? [modelRecord] : [];
-                        if (modelRecords.length > 0 && modelRecords[0].id) {
-                            const propertyRecords = await db
-                                .select()
-                                .from(properties)
-                                .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, itemProperty.propertyName)))
-                                .limit(1);
-                            if (propertyRecords.length > 0) {
-                                const propRecord = propertyRecords[0];
-                                let refModelName;
-                                if (propRecord.refModelId != null) {
-                                    const refModelRows = await db
-                                        .select({ name: models.name })
-                                        .from(models)
-                                        .where(eq(models.id, propRecord.refModelId))
-                                        .limit(1);
-                                    refModelName = refModelRows[0]?.name ?? undefined;
-                                }
-                                schema = {
-                                    dataType: propRecord.dataType,
-                                    ref: refModelName ?? undefined,
-                                    refValueType: propRecord.refValueType || undefined,
-                                    storageType: propRecord.storageType || undefined,
-                                    localStorageDir: propRecord.localStorageDir || undefined,
-                                    filenameSuffix: propRecord.filenameSuffix || undefined,
-                                    required: propRecord.required ?? undefined,
-                                };
-                            }
-                        }
-                    }
-                    catch {
-                        schema = undefined;
-                    }
-                }
-            }
-            if (schema) {
-                itemProperty.getService().send({
-                    type: 'updateContext',
-                    propertyRecordSchema: schema,
-                });
-            }
-        }
-    }
-};
-const processBasicProperties = async (itemBasicProperties, itemPublishData, ctx, buildOpts) => {
-    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
-    for (const basicProperty of itemBasicProperties) {
-        // Skip SDK-internal properties (e.g. publisher) - never attest to EAS
-        if (INTERNAL_PROPERTY_NAMES.includes(basicProperty.propertyName)) {
-            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);
-        const isFileImageHtml = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.File) ||
-            matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Image) ||
-            matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Html);
-        const isJsonStorage = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Json) ||
-            matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Json);
-        const isRelation = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Relation);
-        // storageTransactionId is usually Text in the schema; .value still prefers renderValue (URL, label).
-        const isStorageTransactionIdProp = isStorageTransactionPropertyName(basicProperty.propertyName);
-        // File/Image/Html + Relation + Json storage + storage tx id: use propertyValue (canonical).
-        // basicProperty.value prefers renderValue (filename, blob URL, display text)—never use that for publish.
-        const preferPropertyValueForPublish = isFileImageHtml || isRelation || isJsonStorage || isStorageTransactionIdProp;
-        let value = preferPropertyValueForPublish && context
-            ? context.propertyValue
-            : (basicProperty.value ??
-                (context ? context.propertyValue : undefined));
-        if (!context) {
-            continue;
-        }
-        // Relation + Image/File/Html/Json refs often expose seedLocalId on context.propertyValue while .value is an object — align for encode + resolve hints
-        if (matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Relation) ||
-            isFileImageHtml ||
-            isJsonStorage) {
-            const pv = context.propertyValue;
-            if (typeof value === 'object' || value == null) {
-                if (typeof pv === 'string' && pv.trim())
-                    value = pv.trim();
-                else if (pv && typeof pv === 'object' && typeof pv.seedLocalId === 'string')
-                    value = pv.seedLocalId;
-            }
-        }
-        // 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 === '' || (Array.isArray(value) && value.length === 0)) {
-            if (basicProperty.uid && !forceFullSnapshot)
-                continue;
-            const clear = await getPropertyClear({
-                seedLocalId: context.seedLocalId,
-                seedUid: context.seedUid,
-                propertyName: basicProperty.propertyName,
-                dataType: propertyDef?.dataType,
-                refValueType: propertyDef?.refValueType,
-            });
-            if (!clear || clear.retract) {
-                // An empty List is a value: it attests [] as before
-                if (!(Array.isArray(value) && !clear))
-                    continue;
-            }
-            else {
-                isRemoval = true;
-            }
-        }
-        // Patch mode skips properties that already have an EAS uid. storageTransactionId must still
-        // attest after Arweave upload when we have a tx id; metadata uid can be stale or set without a chain attestation.
-        if (!isRemoval && basicProperty.uid && !forceFullSnapshot) {
-            const allowStorageTxAttestation = isStorageTransactionIdProp &&
-                typeof value === 'string' &&
-                value.trim() !== '';
-            if (!allowStorageTxAttestation) {
-                continue;
-            }
-        }
-        // 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.
-        // Relation/image properties are appended to the basic list after processRelationOrImageProperty,
-        // so this one check covers both paths.
-        if (!isRemoval && isFileImageHtml && typeof value === 'string' && !isStorageSeedRef(value)) {
-            addStorageValueNotSavedError(ctx, basicProperty.propertyName, propertyDef?.dataType, value);
-            continue;
-        }
-        const propertyData = await getPropertyData(basicProperty, ctx);
-        if (!propertyData)
-            continue;
-        const { schemaUid, easDataType, schemaDef, propertyNameForSchema } = propertyData;
-        if (!schemaDef)
-            continue;
-        let rawListIdsForResolve;
-        if (isRemoval) {
-            const empty = emptyEasValue(easDataType);
-            if (empty === undefined) {
-                addValidationError(ctx, `${basicProperty.propertyName} can't be published empty: ${propertyDef?.dataType ?? easDataType} properties have no empty value. Clear it with clear({ retract: true }).`, basicProperty.propertyName, 'publish_clear_unsupported');
-                continue;
-            }
-            value = empty;
-        }
-        else {
-            // Normalize value: string that parses to array (e.g. from browser storage) -> array
-            if (schemaDef.startsWith('bytes32[]') && typeof value === 'string' && value.trim().startsWith('[')) {
-                try {
-                    value = JSON.parse(value);
-                }
-                catch {
-                    // fall through to array check
-                }
-            }
-            // Legacy comma-separated ids (pre-JSON List storage)
-            if (schemaDef.startsWith('bytes32[]') &&
-                typeof value === 'string' &&
-                !value.trim().startsWith('[') &&
-                value.includes(',')) {
-                value = value
-                    .split(',')
-                    .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-CZzKNL04.js');
-                const validationService = new SchemaValidationService();
-                const validationResult = validationService.validatePropertyValue(value, normalizeDataType(propertyDef.dataType), propertyDef.validation, propertyDef.refValueType
-                    ? normalizeDataType(propertyDef.refValueType)
-                    : undefined);
-                if (!validationResult.isValid && validationResult.errors.length > 0) {
-                    const firstError = validationResult.errors[0];
-                    addValidationError(ctx, firstError.message, basicProperty.propertyName, firstError.code ?? 'publish_validation');
-                    continue;
-                }
-            }
-            if (schemaDef.startsWith('bytes32[]')) {
-                const newValues = [];
-                const rawIds = [];
-                const iterableValue = Array.isArray(value) ? value
-                    : value != null && typeof value[Symbol.iterator] === 'function' ? value
-                        : [];
-                for (const seedId of iterableValue) {
-                    const idStr = typeof seedId === 'string'
-                        ? seedId
-                        : seedId &&
-                            typeof seedId === 'object' &&
-                            (seedId.seedLocalId ?? seedId.seedUid ?? seedId.localId ?? seedId.uid)
-                            ? String(seedId.seedLocalId ??
-                                seedId.seedUid ??
-                                '')
-                            : '';
-                    if (!idStr)
-                        continue;
-                    const trimmed = currentRelatedRef(ctx, idStr.trim());
-                    if (!trimmed)
-                        continue;
-                    rawIds.push(trimmed);
-                    if (!isUidRef(trimmed)) {
-                        newValues.push(encodeBytes32String(trimmed));
-                    }
-                    else {
-                        newValues.push(trimmed);
-                    }
-                }
-                value = newValues;
-                const needsUidResolve = rawIds.some((id) => !isUidRef(id));
-                if (needsUidResolve && rawIds.length > 0) {
-                    rawListIdsForResolve = rawIds;
-                }
-            }
-            // uint256 (Date) must be numeric/BigInt; normalize ISO strings to Unix seconds
-            if (easDataType === 'uint256' && (typeof value === 'string' || value instanceof Date)) {
-                const ms = value instanceof Date ? value.getTime() : 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(propertyDef?.dataType, ModelPropertyDataTypes.Number)) {
-                const decimal = decodeEasNumber(value);
-                if (decimal === undefined) {
-                    addValidationError(ctx, `Invalid value for property: ${basicProperty.propertyName}. Expected a finite number, got ${JSON.stringify(value)}.`, basicProperty.propertyName, 'publish_invalid_number');
-                    continue;
-                }
-                value = decimal;
-            }
-        }
-        const data = [
-            {
-                name: propertyNameForSchema,
-                type: easDataType,
-                value,
-            },
-        ];
-        let encodedData;
-        try {
-            const { SchemaEncoder } = await loadEasSdk();
-            const dataEncoder = new SchemaEncoder(schemaDef);
-            encodedData = dataEncoder.encodeData(data);
-        }
-        catch (encodeErr) {
-            addValidationError(ctx, `Failed to encode property ${basicProperty.propertyName}: ${encodeErr instanceof Error ? encodeErr.message : String(encodeErr)}`, basicProperty.propertyName);
-            continue;
-        }
-        // For storageTransactionId, set refUID to versionUid so it references the Version attestation (contract may use when supported)
-        const refUid = isStorageTransactionIdProp
-            ? itemPublishData.versionUid
-            : defaultAttestationData.refUID;
-        const attestationEntry = {
-            schema: schemaUid,
-            data: [
-                {
-                    ...defaultAttestationData,
-                    refUID: refUid,
-                    data: encodedData,
-                },
-            ],
-            // Always set so persist can match metadata rows that lack schemaUid
-            _propertyName: basicProperty.propertyName,
-            // The row whose value this attests; recording gives the uid to exactly that row.
-            ...(context.localId ? { _metadataLocalId: context.localId } : {}),
-        };
-        // For relation/image properties with seedLocalId, store resolution hints for resolvePublishPayloadValues
-        const looksLikeLocalSeedRef = typeof value === 'string' &&
-            !isUidRef(value) &&
-            /^[a-zA-Z0-9_-]{10,21}$/.test(value.trim());
-        if (looksLikeLocalSeedRef &&
-            (easDataType === 'bytes32' || easDataType === 'string')) {
-            attestationEntry._propertyName = basicProperty.propertyName;
-            attestationEntry._propertyNameForSchema = propertyNameForSchema;
-            attestationEntry._schemaDef = schemaDef;
-            attestationEntry._unresolvedValue = value.trim();
-            attestationEntry._easDataType = easDataType;
-        }
-        if (rawListIdsForResolve && rawListIdsForResolve.length > 0) {
-            attestationEntry._propertyName = basicProperty.propertyName;
-            attestationEntry._propertyNameForSchema = propertyNameForSchema;
-            attestationEntry._schemaDef = schemaDef;
-            attestationEntry._easDataType = 'bytes32[]';
-            attestationEntry._rawListIdsForResolve = rawListIdsForResolve;
-        }
-        itemPublishData.listOfAttestations.push(attestationEntry);
-    }
-    return itemPublishData;
-};
-const processRelationOrImageProperty = async (relationOrImageProperty, multiPublishPayload, uploadedTransactions, originalSeedLocalId, ctx, buildOpts) => {
-    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
-    // Resolve from the definition like every other property; the cached schemaUid was found by
-    // name alone and can belong to a schema of another type.
-    let relationOrImageSchemaUid;
-    if (relationOrImageProperty.propertyDef) {
-        const propertyData = await getPropertyData(relationOrImageProperty, ctx);
-        if (!propertyData)
-            return multiPublishPayload;
-        relationOrImageSchemaUid = propertyData.schemaUid;
-    }
-    else {
-        relationOrImageSchemaUid = relationOrImageProperty.schemaUid;
-    }
-    if (!relationOrImageSchemaUid) {
-        addValidationError(ctx, `Schema uid not found for relation or image property: ${relationOrImageProperty.propertyName}`, relationOrImageProperty.propertyName);
-        return multiPublishPayload;
-    }
-    const snapshot = relationOrImageProperty.getService().getSnapshot();
-    const context = 'context' in snapshot ? snapshot.context : null;
-    if (!context) {
-        return multiPublishPayload;
-    }
-    let value = context.propertyValue;
-    // File/Image/Html/Json metadata is stored with Id suffix (e.g. "textId"); context may not have propertyValue
-    // if the property was created from schema before metadata loaded. Fallback to metadata lookup.
-    const isStorageSeed = matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.File) ||
-        matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Image) ||
-        matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Html) ||
-        matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Json) ||
-        (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Relation) &&
-            (matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.File) ||
-                matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.Image) ||
-                matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.Html) ||
-                matchesDataType(relationOrImageProperty.propertyDef?.refValueType, ModelPropertyDataTypes.Json)));
-    if (isStorageSeed && (context.seedLocalId || context.seedUid)) {
-        const _mod_1 = await import('./Item-CG5IhPtL.js');
-        const _ns_1 = _mod_1.au;
-        const { getPropertyData: getPropertyDataFromDb } = _ns_1;
-        const metaRow = await getPropertyDataFromDb({
-            propertyName: relationOrImageProperty.propertyName,
-            seedLocalId: context.seedLocalId,
-            seedUid: context.seedUid,
-        });
-        const fromMeta = metaRow?.propertyValue;
-        if (typeof fromMeta === 'string' && fromMeta.trim() !== '') {
-            const idsCtx = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(value) ?? '');
-            const idsDb = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(fromMeta) ?? '');
-            if (!value) {
-                value = fromMeta;
-            }
-            else if (!idsCtx.seedLocalId && !idsCtx.seedUid && (idsDb.seedLocalId || idsDb.seedUid)) {
-                value = fromMeta;
-            }
-        }
-    }
-    const propertyDef = relationOrImageProperty.propertyDef;
-    let isRequired = propertyDef?.required === true;
-    // Resolve required from schema/DB when propertyDef lacks it
-    if (!isRequired && relationOrImageProperty.modelName) {
-        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 modelRecord = await resolveModelRecord(normalizedModelName, propertyScope);
-            const modelRecords = modelRecord ? [modelRecord] : [];
-            if (modelRecords.length > 0 && modelRecords[0].id) {
-                const propertyRecords = await BaseDb.getAppDb()
-                    .select()
-                    .from(properties)
-                    .where(and(eq(properties.modelId, modelRecords[0].id), eq(properties.name, relationOrImageProperty.propertyName)))
-                    .limit(1);
-                if (propertyRecords.length > 0) {
-                    schema = {
-                        dataType: propertyRecords[0].dataType,
-                        ref: undefined,
-                        required: propertyRecords[0].required ?? undefined,
-                    };
-                }
-            }
-        }
-        if (schema?.required === true || schema?.required === 1) {
-            isRequired = true;
-        }
-    }
-    // Required relation/image/file/html/json with no value: cannot publish
-    if (isRequired && !value) {
-        const typeLabel = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.File) ||
-            matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.File)
-            ? 'file'
-            : matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Image) ||
-                matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Image)
-                ? 'image'
-                : matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Html) ||
-                    matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Html)
-                    ? 'html'
-                    : matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Json) ||
-                        matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Json)
-                        ? 'json'
-                        : 'relation';
-        const refLabel = propertyDef?.ref ?? propertyDef?.refModelName ?? 'related';
-        addValidationError(ctx, `Required ${typeLabel} ${relationOrImageProperty.propertyName} has no value. ` +
-            `A value pointing to a valid ${refLabel} item is required to publish.`, relationOrImageProperty.propertyName);
-        return multiPublishPayload;
-    }
-    if (!value) {
-        return multiPublishPayload;
-    }
-    if (relationOrImageProperty.uid && !forceFullSnapshot) {
-        return multiPublishPayload;
-    }
-    const normalizedRef = normalizeRelationPropertyValue(value);
-    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalizedRef ?? '');
-    // Value is not a valid seed reference (local id or 0x uid)
-    if (!seedLocalId && !seedUid) {
-        if (isRequired) {
-            addValidationError(ctx, `Required relation ${relationOrImageProperty.propertyName} has invalid value: ${JSON.stringify(value)}. ` +
-                `Value must be a valid seed reference (localId or uid) pointing to a ${propertyDef?.ref ?? propertyDef?.refModelName ?? 'related'} item.`, relationOrImageProperty.propertyName);
-        }
-        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;
-    }
-    const relatedItem = await ctx.loads.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.
-        if (isRequired && !isPublishedSeedRef(normalizedRef)) {
-            addValidationError(ctx, `No related item found for required relation: ${relationOrImageProperty.propertyName}. ` +
-                `Value: ${JSON.stringify(value)} (seedLocalId/seedUid). ` +
-                `The related item may be missing, in a different database, or the reference may be broken.`, relationOrImageProperty.propertyName);
-        }
-        return multiPublishPayload;
-    }
-    // When Image/Relation already has seedUid (published), skip creating its payload—only add the property to parent
-    if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
-        return multiPublishPayload;
-    }
-    let modelName;
-    if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Image)) {
-        modelName = 'Image';
-    }
-    if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.File)) {
-        modelName = 'File';
-    }
-    if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Html)) {
-        modelName = 'Html';
-    }
-    if (matchesDataType(relationOrImageProperty.propertyDef?.dataType, ModelPropertyDataTypes.Relation)) {
-        const def = relationOrImageProperty.propertyDef;
-        modelName = def.ref ?? def.refModelName;
-    }
-    if (!modelName) {
-        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}`, reportPropertyName);
-        return multiPublishPayload;
-    }
-    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: ZERO_BYTES32,
-        seedSchemaUid,
-        versionUid: getVersionUid(relatedItem),
-        listOfAttestations: [],
-        propertiesToUpdate: link ? [{ ...link }] : [],
-    };
-    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);
-            }
-        }
-        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);
-    }
-    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) {
-        if (!matchesDataType(p.propertyDef?.dataType, ModelPropertyDataTypes.Html))
-            continue;
-        const snap = p.getService().getSnapshot();
-        const c = 'context' in snap ? snap.context : null;
-        const pv = typeof c?.propertyValue === 'string' ? c.propertyValue.trim() : '';
-        if (pv !== want)
-            continue;
-        // Resolved like the Html property's own attestation, so a schema it lacks fails here too. The
-        // caller only checks that a uid was found: embedded images don't update the Html property.
-        return (await getPropertyData(p, ctx))?.schemaUid;
-    }
-    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, ctx, buildOpts) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return multiPublishPayload;
-    const rows = await appDb
-        .select()
-        .from(htmlEmbeddedImageCoPublish)
-        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, item.seedLocalId));
-    if (rows.length === 0)
-        return multiPublishPayload;
-    const forceFullSnapshot = buildOpts?.forceFullSnapshot === true;
-    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;
-        const relatedItem = await ctx.loads.getItem({ seedLocalId: row.imageSeedLocalId });
-        if (!relatedItem) {
-            addValidationError(ctx, `Embedded Image item not found for seed ${row.imageSeedLocalId}.`, 'html', 'html_embed_image_missing');
-            continue;
-        }
-        if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
-            continue;
-        }
-        const seedSchemaUid = await getEasSchemaUidForModel('Image');
-        if (!seedSchemaUid) {
-            addValidationError(ctx, `Schema UID not found for model: Image`, 'html');
-            continue;
-        }
-        // 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,
-            versionSchemaUid: VERSION_SCHEMA_UID,
-            seedUid: relatedItem.seedUid || ZERO_BYTES32,
-            seedSchemaUid,
-            versionUid,
-            listOfAttestations: [],
-            propertiesToUpdate: [],
-        };
-        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;
-                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,
-        });
-        multiPublishPayload.push(publishPayload);
-    }
-    return multiPublishPayload;
-}
-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) {
-        addValidationError(ctx, `processListProperty requires ref (list of relations). List property "${listProperty.propertyName}" has no ref. List-of-primitives should be in itemBasicProperties.`, listProperty.propertyName);
-        return multiPublishPayload;
-    }
-    const snapshot = listProperty.getService().getSnapshot();
-    const context = 'context' in snapshot ? snapshot.context : null;
-    if (!context) {
-        return multiPublishPayload;
-    }
-    let value = context.propertyValue;
-    if (!value) {
-        return multiPublishPayload;
-    }
-    if (listProperty.uid && !forceFullSnapshot) {
-        return multiPublishPayload;
-    }
-    // Always resolve from the property definition; a cached schemaUid may point at a schema
-    // registered under the schema key (bytes32[] authors) instead of authorIdentityIds.
-    const propertyData = await getPropertyData(listProperty, ctx);
-    if (!propertyData)
-        return multiPublishPayload;
-    const listPropertySchemaUid = propertyData.schemaUid;
-    if (typeof value === 'string') {
-        value = parseListPropertyValueFromStorage(value);
-    }
-    const iterableValue = Array.isArray(value)
-        ? value
-        : value != null
-            ? [value]
-            : [];
-    const members = [];
-    for (const seedId of iterableValue) {
-        const idStr = typeof seedId === 'string'
-            ? seedId
-            : seedId &&
-                typeof seedId === 'object' &&
-                (seedId.seedLocalId ?? seedId.seedUid ?? seedId.localId ?? seedId.uid);
-        if (!idStr)
-            continue;
-        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;
-        const relatedItem = await ctx.loads.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)) {
-                console.error(`No related item found for list property: ${listProperty.propertyName}`);
-            }
-            continue;
-        }
-        if (relatedItem.seedUid && relatedItem.seedUid !== ZERO_BYTES32) {
-            continue;
-        }
-        let modelName;
-        if (listProperty.propertyDef?.ref || listProperty.propertyDef.refModelName) {
-            const def = listProperty.propertyDef;
-            modelName = def.ref ?? def.refModelName;
-        }
-        if (matchesDataType(listProperty.propertyDef?.dataType, ModelPropertyDataTypes.Image)) {
-            modelName = 'Image';
-        }
-        if (matchesDataType(listProperty.propertyDef?.dataType, ModelPropertyDataTypes.File)) {
-            modelName = 'File';
-        }
-        if (matchesDataType(listProperty.propertyDef?.dataType, ModelPropertyDataTypes.Html)) {
-            modelName = 'Html';
-        }
-        if (!modelName) {
-            addValidationError(ctx, `Model name not found for list property: ${listProperty.propertyName}`, listProperty.propertyName);
-            continue;
-        }
-        multiPublishPayload = await processRelatedDraftItem({
-            relatedItem,
-            modelName,
-            fullDraft: true,
-            link: deferred ? null : { publishLocalId: originalSeedLocalId, propertySchemaUid: listPropertySchemaUid },
-            reportPropertyName: listProperty.propertyName,
-            multiPublishPayload,
-            uploadedTransactions,
-            ctx,
-            buildOpts,
-        });
-    }
-    return multiPublishPayload;
-};
-/**
- * Same EAS schema + same encoded attestation bytes (data field). Intentionally ignores refUID so
- * duplicate storageTransactionId rows that only differ by ref (e.g. 0x0 vs version uid) collapse.
- */
-function attestationPayloadDedupeKey(att) {
-    const schema = String(att.schema ?? '').toLowerCase();
-    const dataArr = att.data;
-    const d0 = Array.isArray(dataArr) ? dataArr[0] : undefined;
-    const dataHex = d0 && typeof d0 === 'object' && d0 !== null && 'data' in d0
-        ? String(d0.data ?? '').toLowerCase()
-        : '';
-    return `${schema}:${dataHex}`;
-}
-/**
- * Collapse duplicate rows in listOfAttestations (same schema + encoded payload).
- */
-function dedupeListOfAttestationsInEachPayload(payload) {
-    for (const p of payload) {
-        const list = p.listOfAttestations ?? [];
-        if (list.length <= 1)
-            continue;
-        const seen = new Set();
-        const out = [];
-        for (const a of list) {
-            const k = attestationPayloadDedupeKey(a);
-            if (seen.has(k))
-                continue;
-            seen.add(k);
-            out.push(a);
-        }
-        p.listOfAttestations = out;
-    }
-    return payload;
-}
-/**
- * Merge duplicate PublishPayload rows with the same localId (ordering / batch edge cases).
- * Dedupe listOfAttestations so identical storage tx attestations are not emitted twice.
- */
-function dedupeMultiPublishPayloadByLocalId(payload) {
-    const map = new Map();
-    const order = [];
-    for (const p of payload) {
-        const id = p.localId;
-        const existing = map.get(id);
-        if (!existing) {
-            map.set(id, p);
-            order.push(id);
-            continue;
-        }
-        const ptu = [...(existing.propertiesToUpdate ?? [])];
-        for (const u of p.propertiesToUpdate ?? []) {
-            if (!ptu.some((e) => e.publishLocalId === u.publishLocalId &&
-                String(e.propertySchemaUid ?? '').toLowerCase() ===
-                    String(u.propertySchemaUid ?? '').toLowerCase())) {
-                ptu.push(u);
-            }
-        }
-        existing.propertiesToUpdate = ptu;
-        const seenKeys = new Set((existing.listOfAttestations ?? []).map((a) => attestationPayloadDedupeKey(a)));
-        const merged = [...(existing.listOfAttestations ?? [])];
-        for (const a of p.listOfAttestations ?? []) {
-            const k = attestationPayloadDedupeKey(a);
-            if (seenKeys.has(k))
-                continue;
-            seenKeys.add(k);
-            merged.push(a);
-        }
-        existing.listOfAttestations = merged;
-    }
-    return order.map((id) => map.get(id)).filter(Boolean);
-}
-/**
- * Child File/Image items may keep storageTransactionId only on the item machine's
- * propertyInstances map; allProperties / item.properties can omit it during publish.
- */
-function getStorageTransactionPropertyFromItemInstances(item) {
-    try {
-        const svc = item.getService?.();
-        if (!svc)
-            return undefined;
-        const snap = svc.getSnapshot();
-        const instances = snap.context?.propertyInstances;
-        if (!instances || !(instances instanceof Map))
-            return undefined;
-        const direct = instances.get('storageTransactionId') ?? instances.get('storage_transaction_id');
-        if (direct)
-            return direct;
-        for (const [, p] of instances) {
-            if (p && isStorageTransactionPropertyName(p.propertyName))
-                return p;
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
-/**
- * Resolve storageTransactionId (+ ItemStorage children) for publish.
- * getSegmentedItemProperties can yield empty itemUploadProperties when the child Item never
- * hydrated storageTransactionId into the upload bucket (e.g. only uri/metadata rows), while
- * getStorageSeedUploads still creates an Arweave upload keyed by child seedLocalId.
- */
-function resolveStorageTransactionUploadSlot(item, itemUploadProperties) {
-    const named = itemUploadProperties.find((u) => isStorageTransactionPropertyName(u.itemProperty.propertyName));
-    if (named)
-        return named;
-    if (itemUploadProperties.length === 1)
-        return itemUploadProperties[0];
-    const all = item.allProperties;
-    const fromInstances = getStorageTransactionPropertyFromItemInstances(item);
-    const storagePropEarly = all?.['storageTransactionId'] ??
-        all?.['storage_transaction_id'] ??
-        Object.values(all ?? {}).find((p) => !!p && isStorageTransactionPropertyName(p.propertyName)) ??
-        item.properties?.find((p) => isStorageTransactionPropertyName(p.propertyName));
-    const storageProp = storagePropEarly ?? fromInstances;
-    if (!storageProp)
-        return undefined;
-    const childProps = item.properties?.filter((p) => p.propertyDef &&
-        p.propertyDef.storageType === 'ItemStorage') ?? [];
-    return { itemProperty: storageProp, childProperties: childProps };
-}
-function findUploadedTxForSeedLocalId(uploadedTransactions, seedLocalId) {
-    const t = seedLocalId.trim();
-    return (uploadedTransactions.find((u) => u.seedLocalId === t) ??
-        uploadedTransactions.find((u) => u.seedLocalId != null && u.seedLocalId.trim() === t));
-}
-const getPublishPayload = async (item, uploadedTransactions, options) => {
-    // Every edit made before publishing is in `metadata` first (ADR 0019)
-    const { waitForPendingOutboxOps } = await import('./index-njjjo74v.js');
-    await waitForPendingOutboxOps();
-    const validationCtx = { errors: [], loads: new ItemLoads() };
-    try {
-        return await buildPublishPayload(item, uploadedTransactions, validationCtx, options);
-    }
-    finally {
-        validationCtx.loads.release();
-    }
-};
-const buildPublishPayload = async (item, uploadedTransactions, validationCtx, options) => {
-    const publishMode = options?.publishMode ?? 'patch';
-    // 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
-    // Check if the item has a schema UID
-    let itemSchemaUid = item.schemaUid;
-    if (!itemSchemaUid) {
-        const schemaUid = await getEasSchemaUidForModel(item.modelName);
-        if (!schemaUid) {
-            addValidationError(validationCtx, `Schema UID not found for model: ${item.modelName}`);
-            itemSchemaUid = ZERO_BYTES32; // placeholder so we can continue collecting errors
-        }
-        else {
-            itemSchemaUid = schemaUid;
-        }
-    }
-    let versionUid = getVersionUid(item);
-    if (versionUid === ZERO_BYTES32 && rootSeedUid !== ZERO_BYTES32) {
-        versionUid = await resolveVersionUid(item.seedLocalId, rootSeedUid);
-    }
-    if (forceFullSnapshot && hasSeedUid) {
-        versionUid = ZERO_BYTES32;
-    }
-    let itemPublishData = {
-        localId: item.seedLocalId,
-        seedUid: rootSeedUid,
-        seedIsRevocable: true,
-        seedSchemaUid: itemSchemaUid,
-        versionSchemaUid: VERSION_SCHEMA_UID,
-        versionUid,
-        listOfAttestations: [],
-        propertiesToUpdate: [],
-    };
-    await ensurePropertyDefs(item);
-    const { itemBasicProperties, itemListProperties, itemUploadProperties, itemImageProperties, itemRelationProperties, } = await getSegmentedItemProperties(item);
-    const relationAndImageProperties = [...itemRelationProperties, ...itemImageProperties];
-    // Validate required relations have values before processing
-    for (const relProp of itemRelationProperties) {
-        const snapshot = relProp.getService().getSnapshot();
-        const ctx = 'context' in snapshot ? snapshot.context : null;
-        const val = ctx ? ctx.renderValue ?? ctx.propertyValue : undefined;
-        if (val != null && typeof val === 'string' && val.trim() !== '')
-            continue;
-        // No value - check if required from propertyDef or DB
-        let isRequired = relProp.propertyDef?.required === true;
-        if (!isRequired && BaseDb.getAppDb() && item.modelName) {
-            const normalizedModelName = upperFirst(camelCase(item.modelName));
-            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 })
-                    .from(properties)
-                    .where(and(eq(properties.modelId, modelRows[0].id), eq(properties.name, relProp.propertyName), sql `lower(${properties.dataType}) = 'relation'`))
-                    .limit(1);
-                if (propRows.length > 0 && (propRows[0].required === true || propRows[0].required === 1)) {
-                    isRequired = true;
-                }
-            }
-        }
-        if (isRequired) {
-            const refModel = relProp.propertyDef?.ref ?? relProp.propertyDef?.refModelName ?? 'related';
-            addValidationError(validationCtx, `Required relation ${relProp.propertyName} has no value. ` +
-                `A value pointing to a valid ${refModel} item is required to publish.`, relProp.propertyName);
-        }
-    }
-    const rootStorageUpload = resolveStorageTransactionUploadSlot(item, itemUploadProperties);
-    if (rootStorageUpload) {
-        const transactionData = findUploadedTxForSeedLocalId(uploadedTransactions, item.seedLocalId);
-        if (transactionData) {
-            const itemProperty = rootStorageUpload.itemProperty;
-            itemProperty.getService().send({
-                type: 'updateContext',
-                propertyValue: transactionData.txId,
-                renderValue: transactionData.txId,
-            });
-            replaceStorageTransactionInBasicProperties(itemBasicProperties, itemProperty);
-        }
-    }
-    for (const relationProperty of relationAndImageProperties) {
-        multiPublishPayload = await processRelationOrImageProperty(relationProperty, multiPublishPayload, uploadedTransactions, item.seedLocalId, validationCtx, { forceFullSnapshot });
-        itemBasicProperties.push(relationProperty);
-    }
-    multiPublishPayload = await processHtmlEmbeddedCoPublishImagePayloads(item, multiPublishPayload, uploadedTransactions, validationCtx, { forceFullSnapshot });
-    for (const listProperty of itemListProperties) {
-        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', await getItemModelScope(item));
-            if (schema) {
-                p.getService().send({ type: 'updateContext', propertyRecordSchema: schema });
-            }
-        }
-    }
-    dedupeOneStorageTransactionPropertyInList(itemBasicProperties);
-    itemPublishData = await processBasicProperties(itemBasicProperties, itemPublishData, validationCtx, { forceFullSnapshot });
-    multiPublishPayload.push(itemPublishData);
-    // Ensure requests are ordered so that when A has propertiesToUpdate pointing to B (publishLocalId),
-    // A (the updater) is published before B (the updatee). The contract injects A's seedUid into B's
-    // attestation before B is sent to EAS.
-    multiPublishPayload = dedupeMultiPublishPayloadByLocalId(multiPublishPayload);
-    multiPublishPayload = orderPayloadByDependencies(multiPublishPayload);
-    // Ensure attestations referenced in propertiesToUpdate have at least one data element.
-    // The contract writes the seed UID into data[0].data; empty data causes Panic 50.
-    multiPublishPayload = ensurePropertiesToUpdateAttestationsHaveData(multiPublishPayload);
-    multiPublishPayload = dedupeListOfAttestationsInEachPayload(multiPublishPayload);
-    if (publishMode === 'new_version') {
-        const rootPayload = multiPublishPayload.find((p) => p.localId === item.seedLocalId);
-        const listLen = rootPayload?.listOfAttestations?.length ?? 0;
-        if (!rootPayload || listLen === 0) {
-            addValidationError(validationCtx, 'Publishing as a new version requires at least one property attestation for the item. ' +
-                'Ensure required fields have values and that publishable properties are present.', 'listOfAttestations', 'publish_new_version_empty_snapshot');
-        }
-    }
-    // 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);
-    }
-    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;
-    }
-};
-/**
- * Normalize a schema UID to 0x-prefixed 64-char hex for comparison.
- */
-function normalizeSchemaUid(v) {
-    if (v == null || v === '')
-        return '';
-    const raw = v.startsWith('0x') ? v.slice(2) : v;
-    const hex = raw.replace(/[^0-9a-fA-F]/g, '0').padStart(64, '0').slice(-64);
-    return ('0x' + hex).toLowerCase();
-}
-/**
- * Ensure that when request A has propertiesToUpdate with (publishLocalId: B, propertySchemaUid: X),
- * request B has an attestation for schema X with at least one data element. The contract writes
- * the seed UID into data[0].data; empty data causes Panic 50.
- */
-function ensurePropertiesToUpdateAttestationsHaveData(payload) {
-    const byLocalId = new Map();
-    for (const p of payload) {
-        byLocalId.set(p.localId, p);
-    }
-    const placeholderData = {
-        ...defaultAttestationData,
-        data: ZERO_BYTES32,
-    };
-    for (const req of payload) {
-        for (const pu of req.propertiesToUpdate ?? []) {
-            const targetId = pu.publishLocalId;
-            const schemaUid = pu.propertySchemaUid;
-            if (!targetId || !schemaUid)
-                continue;
-            const targetReq = byLocalId.get(targetId);
-            if (!targetReq?.listOfAttestations)
-                continue;
-            const wantSchema = normalizeSchemaUid(schemaUid);
-            const att = targetReq.listOfAttestations.find((a) => normalizeSchemaUid(a?.schema) === wantSchema);
-            if (!att)
-                continue;
-            if (!Array.isArray(att.data) || att.data.length === 0) {
-                att.data = [placeholderData];
-            }
-        }
-    }
-    return payload;
-}
-/**
- * LocalIds in this batch referenced by attestations (bytes32 / bytes32[]) that must publish before this request.
- */
-function collectAttestationLocalRefIds(req, allLocalIds) {
-    const refs = [];
-    for (const a of req.listOfAttestations ?? []) {
-        const att = a;
-        if (att._unresolvedValue && allLocalIds.has(att._unresolvedValue)) {
-            refs.push(att._unresolvedValue);
-        }
-        if (Array.isArray(att._rawListIdsForResolve)) {
-            for (const id of att._rawListIdsForResolve) {
-                const t = id != null ? String(id).trim() : '';
-                if (t && allLocalIds.has(t))
-                    refs.push(t);
-            }
-        }
-    }
-    return refs;
-}
-/**
- * Topological sort (Kahn): edge `from → to` means `from` must publish before `to`.
- * - propertiesToUpdate: updater before updatee (contract injection).
- * - _unresolvedValue / _rawListIdsForResolve: referenced seed before request that encodes the ref.
- * The previous DFS visit could order [Post, Image] when Post appeared first in the input array,
- * so resolvedUids was empty when Post was published and attestations kept local ids.
- */
-function orderPayloadByDependencies(payload) {
-    if (payload.length <= 1)
-        return payload;
-    const byLocalId = new Map();
-    const allIds = new Set();
-    const indexOrder = new Map();
-    for (let i = 0; i < payload.length; i++) {
-        const p = payload[i];
-        byLocalId.set(p.localId, p);
-        allIds.add(p.localId);
-        indexOrder.set(p.localId, i);
-    }
-    const indegree = new Map();
-    for (const id of allIds)
-        indegree.set(id, 0);
-    const adj = new Map();
-    const addEdge = (from, to) => {
-        if (from === to || !allIds.has(from) || !allIds.has(to))
-            return;
-        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 ?? []) {
-            const targetId = u.publishLocalId;
-            if (targetId && targetId !== p.localId)
-                addEdge(p.localId, targetId);
-        }
-        for (const refId of collectAttestationLocalRefIds(p, allIds)) {
-            addEdge(refId, p.localId);
-        }
-    }
-    const zero = [];
-    for (const id of allIds) {
-        if ((indegree.get(id) ?? 0) === 0)
-            zero.push(id);
-    }
-    zero.sort((a, b) => (indexOrder.get(a) ?? 0) - (indexOrder.get(b) ?? 0));
-    const result = [];
-    const queue = zero;
-    while (queue.length > 0) {
-        const id = queue.shift();
-        const p = byLocalId.get(id);
-        if (p)
-            result.push(p);
-        for (const to of adj.get(id) ?? []) {
-            const next = (indegree.get(to) ?? 0) - 1;
-            indegree.set(to, next);
-            if (next === 0) {
-                queue.push(to);
-                queue.sort((a, b) => (indexOrder.get(a) ?? 0) - (indexOrder.get(b) ?? 0));
-            }
-        }
-    }
-    if (result.length !== payload.length) {
-        const seen = new Set(result.map((r) => r.localId));
-        for (const p of payload) {
-            if (!seen.has(p.localId))
-                result.push(p);
-        }
-    }
-    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-pbin4lk8.js.map