@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.4-next.711.gce2b766

package/dist/getPublishUploads-SFHCbf_y.js

@@ -0,0 +1,648 @@
+import { N as resolveSeedIdsFromRefString, O as normalizeRelationPropertyValue, Q as isPublishedSeedRef, i as isDataType, M as ModelPropertyDataTypes, R as getStorageDirForDataType, J as BaseFileManager, E as BaseDb, o as htmlEmbeddedImageCoPublish, S as getContentSha256, U as buildArweaveContentTags, V as getItemStorageSubdir, W as getItemStorageLocalFileName, m as metadata } from './BasePathResolver-Cm4apKRb.js';
+import { BaseArweaveClient } from '@seedprotocol/arweave';
+import { g as getPublishDraftGraph, a as getSegmentedItemProperties } from './publishDraftGraph-BOn3_Occ.js';
+import debug from 'debug';
+import { I as Item, c as compareMetadataRowsLatestFirst } from './Item-DBFchXpC.js';
+import { eq, and } from 'drizzle-orm';
+import 'pluralize';
+import { r as resolveUploadMimeType } from './mimeTypes-DHAHC4eZ.js';
+import { i as isVerbatimItemStorageDraftRow, c as convertVerbatimItemStorageRow } from './ClientManager-i3nJASkg.js';
+import '@seedprotocol/eas';
+import 'xstate';
+import '@sinclair/typebox';
+import 'drizzle-orm/sqlite-core';
+import 'drizzle-orm/casing';
+import 'lodash-es';
+import 'nanoid';
+import 'nanoid-dictionary';
+import '@seedprotocol/query';
+import '@noble/hashes/sha256';
+import '@noble/hashes/sha3';
+import '@noble/hashes/utils';
+import './index-8O3Uow-Y.js';
+import './model-DGMe-TTm.js';
+import './property-DwPD283A.js';
+import 'rxjs';
+import './tabEvents-9s2WCYw-.js';
+
+/**
+ * `Promise.all(items.map(fn))` with at most `limit` calls in flight. Results keep the input order.
+ * Rejects with the first error (by time); after that no new calls start, though calls already in
+ * flight run to completion.
+ */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    const workerCount = Math.max(1, Math.min(Math.floor(limit) || 1, items.length));
+    let next = 0;
+    let failed = false;
+    const worker = async () => {
+        while (!failed && next < items.length) {
+            const index = next++;
+            try {
+                results[index] = await fn(items[index], index);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: workerCount }, worker));
+    return results;
+}
+
+/**
+ * Composite uploads: several ItemStorage files of one item in a single Arweave transaction.
+ *
+ * Producer: `getPublishUploads.ts` (`processUploadPropertyData`), for an item with a
+ * `storageTransactionId` property and ItemStorage properties (e.g. a Post's `html` and `json`).
+ * Consumer: the download worker (`browser/workers/filesDownload.ts`), which keeps its own copy of
+ * {@link decodeCompositeUpload} because it runs from a string; a test keeps the two in step.
+ *
+ * Format (unchanged for text children, so composites already on Arweave still read):
+ *
+ *   ===FILE_SEPARATOR===<name>===FILE_SEPARATOR===<utf-8 text>   (repeated per child)
+ *
+ * A child that is not valid UTF-8 text (or whose text contains the separator) is written as
+ * base64 under the name `<name>;base64`. Composites written before this suffix existed converted
+ * every child to text, which corrupted binary children; those bytes cannot be recovered.
+ */
+const COMPOSITE_SEPARATOR = '===FILE_SEPARATOR===';
+const COMPOSITE_BASE64_SUFFIX = ';base64';
+const bytesToBase64 = (bytes) => {
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+};
+/** The child's text when it can travel as text: valid UTF-8, no NUL bytes, no separator. */
+const childAsText = (bytes) => {
+    if (bytes.includes(0))
+        return undefined;
+    let text;
+    try {
+        text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        return undefined;
+    }
+    return text.includes(COMPOSITE_SEPARATOR) ? undefined : text;
+};
+const encodeCompositeUpload = (children) => {
+    let composite = '';
+    for (const { name, bytes } of children) {
+        const text = childAsText(bytes);
+        composite +=
+            text !== undefined
+                ? `${COMPOSITE_SEPARATOR}${name}${COMPOSITE_SEPARATOR}${text}`
+                : `${COMPOSITE_SEPARATOR}${name}${COMPOSITE_BASE64_SUFFIX}${COMPOSITE_SEPARATOR}${bytesToBase64(bytes)}`;
+    }
+    return new TextEncoder().encode(composite);
+};
+new TextEncoder().encode(COMPOSITE_SEPARATOR);
+
+const logger = debug('seedSdk:item:getPublishUploads');
+/** L1 transactions {@link getPublishUploads} creates at once (each asks the gateway for price and anchor). */
+const CREATE_TRANSACTION_CONCURRENCY = 4;
+const toUint8Array = async (data) => {
+    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        return new Uint8Array(await data.arrayBuffer());
+    }
+    return new Uint8Array(data);
+};
+/** A local file's bytes plus its MIME type: the Blob's own type, else the name's extension, else a sniff of the bytes. */
+const readUploadFile = async (filePath, fileName = filePath) => {
+    const data = await BaseFileManager.readFileAsBuffer(filePath);
+    const bytes = await toUint8Array(data);
+    const sourceType = typeof Blob !== 'undefined' && data instanceof Blob ? data.type : undefined;
+    return { bytes, contentType: resolveUploadMimeType({ sourceType, fileName, bytes }) };
+};
+/**
+ * The one place an upload's bytes become a {@link PublishUploadData}: everything after this
+ * (Content-SHA-256, tags, the L1 transaction or the bundler DataItem, signing) works from what it
+ * returns. A future private-publish option that encrypts content belongs here, before the hash and
+ * tags are computed, so both publish paths pick it up.
+ */
+const buildPublishUploadData = (data, contentType, target, options) => {
+    const contentHash = getContentSha256(data);
+    return {
+        data,
+        contentHash,
+        contentType,
+        tags: buildArweaveContentTags(contentHash, contentType, options?.arweaveUploadTags),
+        ...target,
+    };
+};
+const DATA_URI_IMAGE = /^data:(image\/[a-zA-Z0-9.+-]+);base64,([\s\S]*)$/i;
+function decodeDataUriImage(dataUri) {
+    const m = DATA_URI_IMAGE.exec((dataUri ?? '').trim());
+    if (!m)
+        return null;
+    try {
+        const mimeType = m[1].toLowerCase().trim();
+        const base64 = m[2].replace(/\s/g, '');
+        const binary = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+        return { mimeType, bytes: binary };
+    }
+    catch {
+        return null;
+    }
+}
+const getStorageSeedUploadData = async (itemStorageSeedProperties, options) => {
+    const uploads = [];
+    for (const itemProperty of itemStorageSeedProperties) {
+        const snapshot = itemProperty.getService().getSnapshot();
+        const context = 'context' in snapshot ? snapshot.context : null;
+        if (!context) {
+            continue;
+        }
+        const propertyValue = context.propertyValue;
+        const refResolvedValue = context.refResolvedValue;
+        if (!refResolvedValue) {
+            continue;
+        }
+        // propertyValue is the storage seed's seedLocalId; use it for the upload so processRelationOrImageProperty can match
+        const { seedLocalId } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId) {
+            continue;
+        }
+        const dataType = itemProperty.propertyDef?.refValueType ??
+            itemProperty.propertyDef?.dataType ??
+            'Image';
+        if (isDataType(dataType, ModelPropertyDataTypes.Html)) {
+            if (options?.deferHtmlStorageSeedLocalIds?.includes(seedLocalId)) {
+                continue;
+            }
+            if (options?.onlyHtmlStorageSeedLocalIds?.length &&
+                !options.onlyHtmlStorageSeedLocalIds.includes(seedLocalId)) {
+                continue;
+            }
+        }
+        else if (options?.onlyHtmlStorageSeedLocalIds?.length) {
+            continue;
+        }
+        const baseDir = getStorageDirForDataType(dataType);
+        const filePath = `${baseDir}/${refResolvedValue}`;
+        const exists = await BaseFileManager.pathExists(filePath);
+        if (!exists) {
+            continue;
+        }
+        const { bytes: fileContents, contentType } = await readUploadFile(filePath, refResolvedValue);
+        uploads.push(buildPublishUploadData(fileContents, contentType, {
+            itemPropertyName: itemProperty.propertyName,
+            itemPropertyLocalId: itemProperty.localId,
+            seedLocalId,
+            versionLocalId: itemProperty.versionLocalId,
+        }, options));
+    }
+    return uploads;
+};
+async function appendCoPublishedImageUploadData(item, uploads, options) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || options?.onlyHtmlStorageSeedLocalIds?.length)
+        return uploads;
+    const rows = await appDb
+        .select()
+        .from(htmlEmbeddedImageCoPublish)
+        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, item.seedLocalId));
+    const seen = new Set(uploads.map((u) => u.seedLocalId));
+    for (const row of rows) {
+        if (seen.has(row.imageSeedLocalId))
+            continue;
+        const imageItem = await Item.find({ seedLocalId: row.imageSeedLocalId, modelName: 'Image' });
+        if (!imageItem)
+            continue;
+        const st = imageItem.internalProperties['storageTransactionId'] ??
+            imageItem.allProperties['storageTransactionId'];
+        const stSnap = st?.getService().getSnapshot();
+        const stCtx = stSnap && 'context' in stSnap ? stSnap.context : undefined;
+        const stValue = typeof stCtx?.propertyValue === 'string'
+            ? (stCtx.propertyValue ?? '')
+            : '';
+        const decoded = decodeDataUriImage(stValue);
+        const more = [];
+        if (decoded && st && st.localId && st.versionLocalId) {
+            more.push(buildPublishUploadData(decoded.bytes, decoded.mimeType, {
+                itemPropertyName: st.propertyName,
+                itemPropertyLocalId: st.localId,
+                seedLocalId: imageItem.seedLocalId,
+                versionLocalId: st.versionLocalId,
+            }, options));
+        }
+        for (const u of more) {
+            if (!seen.has(u.seedLocalId)) {
+                uploads.push(u);
+                seen.add(u.seedLocalId);
+            }
+        }
+    }
+    return uploads;
+}
+const isUsablePath = (filePath) => !!filePath && !filePath.endsWith('undefined') && !filePath.endsWith('null');
+/** The newest metadata row of an ItemStorage property, read from the DB (not the live query). */
+const getLatestItemStorageRow = async (childProperty) => {
+    const appDb = BaseDb.getAppDb();
+    const seedLocalId = childProperty.seedLocalId;
+    const propertyName = childProperty.storagePropertyName || childProperty.propertyName;
+    if (!appDb || !seedLocalId || !propertyName)
+        return undefined;
+    const where = [eq(metadata.seedLocalId, seedLocalId), eq(metadata.propertyName, propertyName)];
+    if (childProperty.versionLocalId)
+        where.push(eq(metadata.versionLocalId, childProperty.versionLocalId));
+    const rows = await appDb.select().from(metadata).where(and(...where));
+    return [...rows].sort(compareMetadataRowsLatestFirst)[0];
+};
+/**
+ * Write a legacy ItemStorage draft row's verbatim content to `<seedUid or seedLocalId><extension>`
+ * and record it on the row (refResolvedValue, localStorageDir) and in the property context. The
+ * row's propertyValue is cleared once the file is written, so the row has the same shape as one a
+ * save makes and a later edit of the file never leaves stale text behind it.
+ */
+const migrateVerbatimItemStorageRow = async (childProperty, row) => {
+    const seedId = row.seedUid || childProperty.seedUid || row.seedLocalId || childProperty.seedLocalId;
+    if (!seedId || !row.localId)
+        return undefined;
+    const propertyDef = childProperty.propertyDef;
+    const converted = await convertVerbatimItemStorageRow(row.localId, {
+        seedId,
+        localStorageDir: propertyDef?.localStorageDir || row.localStorageDir,
+        filenameSuffix: propertyDef?.filenameSuffix,
+    });
+    if (!converted)
+        return undefined;
+    const { fileName, filePath, localStorageDir, content } = converted;
+    // The content is still the value: keep it as renderValue (the property may show it from propertyValue).
+    childProperty.getService().send({
+        type: 'updateContext',
+        refResolvedValue: fileName,
+        localStorageDir,
+        renderValue: content,
+    });
+    logger(`resolveItemStorageChildFile: wrote verbatim ${childProperty.propertyName} content to ${filePath}`);
+    return filePath;
+};
+/**
+ * Local file of one ItemStorage child of a composite upload. Tries, in order: the property's
+ * localStoragePath (context set by save / hydration / the live query), its newest metadata row's
+ * refResolvedValue + localStorageDir, then (for a local draft whose propertyValue is the content
+ * itself, as rows made before Item.create saved ItemStorage values) that content written to its
+ * file, then (for a local draft, or no row) the name
+ * saveItemStorage gives a new file (`<seedUid or seedLocalId><extension>` in the model's storage
+ * directory). A published or derived row is never swapped for a local file of another name: that
+ * file would be older content.
+ *
+ * `missingLocalEdit` lists the paths tried when nothing exists although the newest row is a saved
+ * local edit (no attestation uid, not derived from one, refResolvedValue set by saveItemStorage):
+ * that edit's file should be there. A published or derived row without a file (e.g. content not
+ * downloaded, or a property the composite never had) is skipped as before.
+ */
+const resolveItemStorageChildFile = async (childProperty) => {
+    const tried = [];
+    const tryPath = async (filePath) => {
+        if (!isUsablePath(filePath) || tried.includes(filePath))
+            return undefined;
+        tried.push(filePath);
+        return (await BaseFileManager.pathExists(filePath)) ? filePath : undefined;
+    };
+    const fromContext = await tryPath(childProperty.localStoragePath);
+    if (fromContext)
+        return { filePath: fromContext };
+    const row = await getLatestItemStorageRow(childProperty).catch((error) => {
+        logger('resolveItemStorageChildFile: metadata lookup failed', error);
+        return undefined;
+    });
+    const propertyDef = childProperty.propertyDef;
+    const dir = getItemStorageSubdir(propertyDef?.localStorageDir || row?.localStorageDir);
+    if (row?.refResolvedValue) {
+        const fromRow = await tryPath(BaseFileManager.getFilesPath(dir, row.refResolvedValue));
+        if (fromRow)
+            return { filePath: fromRow };
+    }
+    const isLocalDraft = !!row && !row.uid && row.derivedFromUid == null;
+    // A local draft holding the content itself (no file reference): what Item.create / createNewItem
+    // stored for ItemStorage values before they went through the save pipeline. Write it to the file a
+    // save would have, point the row and the property at it, and upload that.
+    if (row && isVerbatimItemStorageDraftRow(row)) {
+        const migrated = await migrateVerbatimItemStorageRow(childProperty, row).catch((error) => {
+            logger('resolveItemStorageChildFile: writing verbatim ItemStorage content failed', error);
+            return undefined;
+        });
+        if (migrated)
+            return { filePath: migrated };
+    }
+    const suffix = propertyDef?.filenameSuffix;
+    const seedIds = !row || isLocalDraft
+        ? [row?.seedUid, childProperty.seedUid, row?.seedLocalId, childProperty.seedLocalId]
+        : [];
+    for (const seedId of seedIds) {
+        if (!seedId)
+            continue;
+        const derived = await tryPath(BaseFileManager.getFilesPath(dir, getItemStorageLocalFileName(seedId, suffix)));
+        if (derived)
+            return { filePath: derived };
+    }
+    // saveItemStorage sets refResolvedValue on the draft row once the file is written. A draft row
+    // without one is the empty row createNewItem makes for every model property: nothing to upload.
+    return isLocalDraft && !!row?.refResolvedValue ? { missingLocalEdit: tried } : {};
+};
+/**
+ * True if publish would include at least one Arweave upload (local file / storage seed present).
+ * Does not create Arweave transactions or hit the network — use for routing (e.g. skip EAS-only)
+ * when {@link getPublishUploads} would fail early (e.g. gateway unreachable during tx creation).
+ */
+async function storageSeedHasUploadCandidates(itemStorageSeedProperties) {
+    for (const itemProperty of itemStorageSeedProperties) {
+        const snapshot = itemProperty.getService().getSnapshot();
+        const context = 'context' in snapshot ? snapshot.context : null;
+        if (!context) {
+            continue;
+        }
+        const propertyValue = context.propertyValue;
+        const refResolvedValue = context.refResolvedValue;
+        if (!refResolvedValue) {
+            continue;
+        }
+        const { seedLocalId } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId) {
+            continue;
+        }
+        const dataType = itemProperty.propertyDef?.refValueType ??
+            itemProperty.propertyDef?.dataType ??
+            'Image';
+        const baseDir = getStorageDirForDataType(dataType);
+        const filePath = `${baseDir}/${refResolvedValue}`;
+        if (await BaseFileManager.pathExists(filePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function uploadPropertyWouldUpload(uploadProperty, relatedItemProperty) {
+    for (const childProperty of uploadProperty.childProperties) {
+        // Not strict: a local edit whose file is missing still means "would upload", so the publish
+        // goes ahead and fails loudly in processUploadPropertyData instead of skipping the upload.
+        const resolved = await resolveItemStorageChildFile(childProperty);
+        if (resolved.filePath || resolved.missingLocalEdit) {
+            return true;
+        }
+    }
+    if (relatedItemProperty && relatedItemProperty.localStoragePath) {
+        const filePath = relatedItemProperty.localStoragePath;
+        if (!filePath || filePath.endsWith('undefined')) {
+            return false;
+        }
+        return await BaseFileManager.pathExists(filePath);
+    }
+    return false;
+}
+async function itemOwnUploadCandidates(item, relatedItemProperty, recurseStorageRelations) {
+    const { itemUploadProperties, itemRelationProperties, itemImageProperties } = await getSegmentedItemProperties(item);
+    for (const uploadProperty of itemUploadProperties) {
+        if (await uploadPropertyWouldUpload(uploadProperty, relatedItemProperty)) {
+            return true;
+        }
+    }
+    if (await storageSeedHasUploadCandidates(itemImageProperties)) {
+        return true;
+    }
+    if (!recurseStorageRelations)
+        return false;
+    const storageProperties = new Set(itemImageProperties);
+    for (const relationProperty of itemRelationProperties) {
+        if (!storageProperties.has(relationProperty))
+            continue;
+        const snapshot = relationProperty.getService().getSnapshot();
+        const context = 'context' in snapshot ? snapshot.context : null;
+        if (!context) {
+            continue;
+        }
+        const propertyValue = context.propertyValue;
+        if (!propertyValue || relationProperty.uid) {
+            continue;
+        }
+        const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId && !seedUid) {
+            throw new Error(`Invalid relation value for ${relationProperty.propertyName}: expected local seed id or 0x uid`);
+        }
+        const relatedItem = await Item.find({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            // Related seed referenced by attested uid with no local copy: already published, nothing to upload.
+            if (isPublishedSeedRef(propertyValue))
+                continue;
+            throw new Error(`No relatedItem found for ${relationProperty.propertyName}`);
+        }
+        if (await itemOwnUploadCandidates(relatedItem, relationProperty, false)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Same walk as getPublishUploads: the item and the draft items its publish carries along. */
+async function itemHasPublishUploadCandidates(item, relatedItemProperty) {
+    if (await itemOwnUploadCandidates(item, relatedItemProperty, true))
+        return true;
+    const { drafts } = await getPublishDraftGraph(item, { strict: true });
+    for (const { item: draft, via, viaList } of drafts) {
+        if (await itemOwnUploadCandidates(draft, viaList ? undefined : via, true))
+            return true;
+    }
+    return false;
+}
+const processUploadPropertyData = async (uploadProperty, uploads, relatedItemProperty, options) => {
+    const itemProperty = uploadProperty.itemProperty;
+    const childUploads = [];
+    for (const childProperty of uploadProperty.childProperties) {
+        const { filePath, missingLocalEdit } = await resolveItemStorageChildFile(childProperty);
+        if (!filePath) {
+            if (missingLocalEdit) {
+                // Uploading without it would publish a composite that silently lacks this edit.
+                throw new Error(`Cannot publish ${itemProperty.seedLocalId}: the local file for ${childProperty.propertyName} ` +
+                    `was not found (looked in ${missingLocalEdit.join(', ')})`);
+            }
+            continue;
+        }
+        childUploads.push({
+            propertyName: childProperty.propertyName,
+            localStoragePath: filePath,
+        });
+    }
+    let fileContents;
+    let fileContentType;
+    if (!childUploads || childUploads.length === 0) {
+        if (relatedItemProperty && relatedItemProperty.localStoragePath) {
+            const filePath = relatedItemProperty.localStoragePath;
+            if (!filePath || filePath.endsWith('undefined')) {
+                return uploads;
+            }
+            const exists = await BaseFileManager.pathExists(filePath);
+            if (!exists) {
+                return uploads;
+            }
+            try {
+                const read = await readUploadFile(filePath);
+                fileContents = read.bytes;
+                fileContentType = read.contentType;
+            }
+            catch (e) {
+                const fs = await BaseFileManager.getFs();
+                fileContents = await toUint8Array(fs.readFileSync(filePath));
+                fileContentType = resolveUploadMimeType({ fileName: filePath, bytes: fileContents });
+            }
+        }
+        if (!fileContents) {
+            return uploads;
+        }
+    }
+    if (childUploads.length > 0) {
+        // Composite of the item's ItemStorage files; see helpers/compositeUpload.ts for the format.
+        // Children are read as bytes: a binary child is base64-framed instead of decoded as text.
+        const children = [];
+        const fs = await BaseFileManager.getFs();
+        for (const childUpload of childUploads) {
+            let childUploadContents;
+            try {
+                childUploadContents = await fs.promises.readFile(childUpload.localStoragePath);
+            }
+            catch (e) {
+                childUploadContents = fs.readFileSync(childUpload.localStoragePath);
+            }
+            children.push({
+                name: childUpload.propertyName,
+                bytes: typeof childUploadContents === 'string'
+                    ? new TextEncoder().encode(childUploadContents)
+                    : new Uint8Array(childUploadContents),
+            });
+        }
+        fileContents = encodeCompositeUpload(children);
+    }
+    if (!fileContents) {
+        throw new Error(`No file contents found for ${itemProperty.propertyName}`);
+    }
+    const uint8Array = new Uint8Array(fileContents);
+    let contentType;
+    if (childUploads.length === 0 && relatedItemProperty?.localStoragePath) {
+        contentType = fileContentType;
+    }
+    else if (childUploads.length > 0) {
+        contentType = 'application/octet-stream';
+    }
+    let itemPropertyLocalId = relatedItemProperty
+        ? relatedItemProperty.localId
+        : itemProperty.localId;
+    let itemPropertyName = relatedItemProperty
+        ? relatedItemProperty.propertyName
+        : itemProperty.propertyName;
+    uploads.push(buildPublishUploadData(uint8Array, contentType, {
+        itemPropertyName,
+        itemPropertyLocalId,
+        seedLocalId: itemProperty.seedLocalId,
+        versionLocalId: itemProperty.versionLocalId,
+    }, options));
+    return uploads;
+};
+/** No seed uid yet: a related item in this state is published together with the item. */
+const isDraftItem = (item) => !item.seedUid || item.seedUid === '0x' + '0'.repeat(64);
+/** One item's own uploads: its files, storage seeds, Html-embedded images, and the items its storage relations point at. */
+const getItemOwnPublishUploadData = async (item, uploads, relatedItemProperty, options) => {
+    const { itemUploadProperties, itemRelationProperties, itemImageProperties } = await getSegmentedItemProperties(item);
+    // Phase 2 of an embedded-image publish: only the deferred Html storage seeds, of this item and of
+    // the related items published with it (whose Html can embed images too).
+    const onlyDeferredHtml = !!options?.onlyHtmlStorageSeedLocalIds?.length;
+    if (onlyDeferredHtml) {
+        const storageSeedUploads = await getStorageSeedUploadData(itemImageProperties, options);
+        uploads.push(...storageSeedUploads);
+    }
+    else {
+        for (const uploadProperty of itemUploadProperties) {
+            uploads = await processUploadPropertyData(uploadProperty, uploads, relatedItemProperty, options);
+        }
+        const storageSeedUploads = await getStorageSeedUploadData(itemImageProperties, options);
+        uploads.push(...storageSeedUploads);
+        // Images embedded in this item's Html: the published item's, and a related draft's published with it.
+        if (!relatedItemProperty || isDraftItem(item)) {
+            uploads = await appendCoPublishedImageUploadData(item, uploads, options);
+        }
+    }
+    if (options?.skipRelationRecursion) {
+        return uploads;
+    }
+    // Relations to Image/File/Html/Json items: their file, read through the relation property.
+    const storageProperties = new Set(itemImageProperties);
+    for (const relationProperty of itemRelationProperties) {
+        if (!storageProperties.has(relationProperty))
+            continue;
+        const snapshot = relationProperty.getService().getSnapshot();
+        const context = 'context' in snapshot ? snapshot.context : null;
+        if (!context) {
+            continue;
+        }
+        const propertyValue = context.propertyValue;
+        if (!propertyValue || relationProperty.uid) {
+            continue;
+        }
+        const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId && !seedUid) {
+            throw new Error(`Invalid relation value for ${relationProperty.propertyName}: expected local seed id or 0x uid`);
+        }
+        const relatedItem = await Item.find({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            // Related seed referenced by attested uid with no local copy: already published, nothing to upload.
+            if (isPublishedSeedRef(propertyValue))
+                continue;
+            throw new Error(`No relatedItem found for ${relationProperty.propertyName}`);
+        }
+        uploads = await getItemOwnPublishUploadData(relatedItem, uploads, relationProperty, {
+            ...options,
+            skipRelationRecursion: true,
+        });
+    }
+    return uploads;
+};
+/**
+ * Upload data for a publish of `item`: its own, and that of every draft item the publish carries
+ * along (reachable through relation and list properties, see publishDraftGraph.ts). Raw bytes plus
+ * Content-SHA-256 / Content-Type / configured tags; no Arweave transaction is created, so this
+ * does not touch the network. The bundler path in `@seedprotocol/publish` signs these as
+ * DataItems; {@link getPublishUploads} turns them into L1 transactions.
+ */
+const getPublishUploadData = async (item, uploads = [], relatedItemProperty, options) => {
+    uploads = await getItemOwnPublishUploadData(item, uploads, relatedItemProperty, options);
+    if (options?.skipRelationRecursion) {
+        return uploads;
+    }
+    const { drafts } = await getPublishDraftGraph(item, { strict: true });
+    for (const { item: draft, via, viaList } of drafts) {
+        uploads = await getItemOwnPublishUploadData(draft, uploads, viaList ? undefined : via, options);
+    }
+    return uploads;
+};
+/**
+ * Arweave L1 transactions for a publish of `item`: {@link getPublishUploadData}, each made into an
+ * unsigned transaction carrying the same tags.
+ */
+const getPublishUploads = async (item, uploads = [], relatedItemProperty, options) => {
+    const uploadData = await getPublishUploadData(item, [], relatedItemProperty, options);
+    // Each createTransaction fetches the price / anchor from the gateway: run a few at once.
+    const created = await mapWithConcurrency(uploadData, CREATE_TRANSACTION_CONCURRENCY, async (upload) => ({
+        itemPropertyName: upload.itemPropertyName,
+        itemPropertyLocalId: upload.itemPropertyLocalId,
+        seedLocalId: upload.seedLocalId,
+        versionLocalId: upload.versionLocalId,
+        transactionToSign: await BaseArweaveClient.createTransaction(upload.data, {
+            tags: upload.tags.length ? upload.tags : undefined,
+        }),
+    }));
+    uploads.push(...created);
+    return uploads;
+};
+
+export { CREATE_TRANSACTION_CONCURRENCY, getPublishUploadData, getPublishUploads, itemHasPublishUploadCandidates, resolveItemStorageChildFile };
+//# sourceMappingURL=getPublishUploads-SFHCbf_y.js.map