@seedprotocol/sdk 0.7.2 → 0.7.3-next.654.g52217f6

package/dist/cjs/getPublishUploads-DsXY9S4U.js

@@ -0,0 +1,872 @@
+'use strict';
+
+var main_cjs = require('./index-C4XlgCJ4.js');
+var arweave = require('@seedprotocol/arweave');
+var publishDraftGraph = require('./publishDraftGraph-3ASwAlD7.js');
+var debug = require('debug');
+var drizzleOrm = require('drizzle-orm');
+require('pluralize');
+require('immer');
+require('reflect-metadata');
+require('xstate');
+require('drizzle-orm/sqlite-core');
+require('@seedprotocol/eas');
+require('@sinclair/typebox');
+require('drizzle-orm/casing');
+require('lodash-es');
+require('@noble/hashes/sha256');
+require('@noble/hashes/sha3');
+require('@noble/hashes/utils');
+require('nanoid');
+require('nanoid-dictionary');
+require('@seedprotocol/query');
+require('rxjs');
+require('fs/promises');
+require('fs');
+require('path');
+require('url');
+require('node:url');
+require('@libsql/client');
+require('drizzle-orm/libsql');
+require('drizzle-orm/libsql/migrator');
+require('js-yaml');
+require('child_process');
+require('@seedprotocol/arweave/node');
+require('@seedprotocol/eas/node');
+require('./property-fa0iju0J.js');
+
+/**
+ * File extension <-> MIME type, shared by the upload side (`getPublishUploads.ts`, which sets the
+ * `Content-Type` tag) and the download worker (`browser/workers/filesDownload.ts`, which picks the
+ * extension of a file saved under `files/`). The worker runs from a string and cannot import this
+ * module, so {@link MIME_TO_EXTENSION} is injected into its source as JSON.
+ */
+/**
+ * Lowercase extension (no dot) to MIME type. Includes the odd extensions the SDK itself produces:
+ * `saveImage` names a file `<id>.<subtype>` (e.g. `.svg+xml`, `.x-icon`), so subtypes appear here too.
+ */
+const EXTENSION_TO_MIME = {
+    // images
+    png: 'image/png',
+    apng: 'image/apng',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    jfif: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    heic: 'image/heic',
+    heif: 'image/heif',
+    svg: 'image/svg+xml',
+    'svg+xml': 'image/svg+xml',
+    bmp: 'image/bmp',
+    ico: 'image/x-icon',
+    'x-icon': 'image/x-icon',
+    'vnd.microsoft.icon': 'image/x-icon',
+    tif: 'image/tiff',
+    tiff: 'image/tiff',
+    // text / documents
+    html: 'text/html',
+    htm: 'text/html',
+    xhtml: 'application/xhtml+xml',
+    json: 'application/json',
+    txt: 'text/plain',
+    plain: 'text/plain',
+    md: 'text/markdown',
+    markdown: 'text/markdown',
+    csv: 'text/csv',
+    tsv: 'text/tab-separated-values',
+    xml: 'application/xml',
+    css: 'text/css',
+    js: 'text/javascript',
+    mjs: 'text/javascript',
+    pdf: 'application/pdf',
+    rtf: 'application/rtf',
+    epub: 'application/epub+zip',
+    zip: 'application/zip',
+    gz: 'application/gzip',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    odt: 'application/vnd.oasis.opendocument.text',
+    // audio
+    mp3: 'audio/mpeg',
+    mpeg: 'audio/mpeg',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    oga: 'audio/ogg',
+    opus: 'audio/opus',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    flac: 'audio/flac',
+    weba: 'audio/webm',
+    // video
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    webm: 'video/webm',
+    mov: 'video/quicktime',
+    quicktime: 'video/quicktime',
+    ogv: 'video/ogg',
+    mkv: 'video/x-matroska',
+    avi: 'video/x-msvideo',
+    // fonts
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    otf: 'font/otf',
+};
+/**
+ * MIME type to the extension a downloaded file gets. One canonical extension per type (the
+ * first one listed here wins over {@link EXTENSION_TO_MIME}'s aliases), plus a few common
+ * non-canonical spellings a gateway may send.
+ */
+(() => {
+    const preferred = {
+        'image/jpeg': 'jpg',
+        'image/svg+xml': 'svg',
+        'image/x-icon': 'ico',
+        'image/tiff': 'tiff',
+        'text/html': 'html',
+        'text/plain': 'txt',
+        'text/markdown': 'md',
+        'text/javascript': 'js',
+        'audio/mpeg': 'mp3',
+        'audio/ogg': 'ogg',
+        'audio/mp4': 'm4a',
+        'video/mp4': 'mp4',
+        'video/quicktime': 'mov',
+        'video/ogg': 'ogv',
+    };
+    const out = { ...preferred };
+    for (const [ext, mime] of Object.entries(EXTENSION_TO_MIME)) {
+        if (!(mime in out))
+            out[mime] = ext;
+    }
+    // Non-canonical names some servers use for the same formats.
+    Object.assign(out, {
+        'audio/mp3': 'mp3',
+        'audio/x-wav': 'wav',
+        'audio/wave': 'wav',
+        'audio/vnd.wave': 'wav',
+        'audio/x-m4a': 'm4a',
+        'audio/x-flac': 'flac',
+        'application/x-zip-compressed': 'zip',
+        'image/vnd.microsoft.icon': 'ico',
+    });
+    return out;
+})();
+/**
+ * Content types that say nothing about the content. A Blob carrying one of these is treated as
+ * untyped.
+ */
+const GENERIC_MIME_TYPES = [
+    '',
+    'application/octet-stream',
+    'binary/octet-stream',
+];
+/** Lowercase `type/subtype` without parameters; `undefined` when empty or generic. */
+const normalizeMimeType = (mimeType) => {
+    const t = (mimeType ?? '').split(';')[0].trim().toLowerCase();
+    if (!t || GENERIC_MIME_TYPES.includes(t) || !t.includes('/'))
+        return undefined;
+    return t;
+};
+/** MIME type for a path or file name by its extension, if it has a known one. */
+const getMimeTypeFromPath = (filePathOrName) => {
+    const name = filePathOrName.split('/').pop() ?? '';
+    const dot = name.lastIndexOf('.');
+    if (dot <= 0 || dot === name.length - 1)
+        return undefined;
+    return EXTENSION_TO_MIME[name.slice(dot + 1).toLowerCase()];
+};
+/**
+ * MIME type from the leading bytes, for formats with an unambiguous signature. Used when a local
+ * file has no (known) extension, e.g. a file seed named after its id.
+ */
+const sniffMimeType = (bytes) => {
+    const at = (offset, ...sig) => bytes.length >= offset + sig.length && sig.every((b, i) => bytes[offset + i] === b);
+    const ascii = (offset, s) => at(offset, ...Array.from(s).map((c) => c.charCodeAt(0)));
+    if (at(0, 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+        return 'image/png';
+    if (at(0, 0xff, 0xd8, 0xff))
+        return 'image/jpeg';
+    if (ascii(0, 'GIF87a') || ascii(0, 'GIF89a'))
+        return 'image/gif';
+    if (ascii(0, 'RIFF') && ascii(8, 'WEBP'))
+        return 'image/webp';
+    if (ascii(0, 'RIFF') && ascii(8, 'WAVE'))
+        return 'audio/wav';
+    if (ascii(0, 'RIFF') && ascii(8, 'AVI '))
+        return 'video/x-msvideo';
+    if (ascii(0, 'BM') && bytes.length > 14)
+        return 'image/bmp';
+    if (at(0, 0x49, 0x49, 0x2a, 0x00) || at(0, 0x4d, 0x4d, 0x00, 0x2a))
+        return 'image/tiff';
+    if (ascii(0, '%PDF-'))
+        return 'application/pdf';
+    if (ascii(0, 'OggS'))
+        return 'audio/ogg';
+    if (ascii(0, 'fLaC'))
+        return 'audio/flac';
+    if (ascii(0, 'ID3'))
+        return 'audio/mpeg';
+    if (at(0, 0x1a, 0x45, 0xdf, 0xa3))
+        return 'video/webm';
+    if (ascii(4, 'ftyp')) {
+        const brand = String.fromCharCode(...Array.from(bytes.slice(8, 12)));
+        if (brand === 'avif' || brand === 'avis')
+            return 'image/avif';
+        if (['heic', 'heix', 'heif', 'mif1', 'msf1'].includes(brand))
+            return 'image/heic';
+        if (brand === 'qt  ')
+            return 'video/quicktime';
+        if (brand === 'M4A ')
+            return 'audio/mp4';
+        return 'video/mp4';
+    }
+    return undefined;
+};
+/**
+ * Best MIME type for upload bytes: the source's own type (a Blob/File `type`) when it is specific,
+ * then the file name's extension, then the bytes' signature.
+ */
+const resolveUploadMimeType = (params) => normalizeMimeType(params.sourceType) ??
+    (params.fileName ? getMimeTypeFromPath(params.fileName) : undefined) ??
+    (params.bytes ? sniffMimeType(params.bytes) : undefined);
+
+/**
+ * `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 main_cjs.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 }) };
+};
+const prepareArweaveTransaction = async (data, contentHash, contentType, additionalTags) => {
+    const tags = main_cjs.buildArweaveContentTags(contentHash, contentType, additionalTags);
+    const tx = await arweave.BaseArweaveClient.createTransaction(data, {
+        tags: tags.length ? tags : undefined,
+    });
+    return tx;
+};
+/**
+ * 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 = main_cjs.getContentSha256(data);
+    return {
+        data,
+        contentHash,
+        contentType,
+        tags: main_cjs.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 } = main_cjs.resolveSeedIdsFromRefString(main_cjs.normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId) {
+            continue;
+        }
+        const dataType = itemProperty.propertyDef?.refValueType ??
+            itemProperty.propertyDef?.dataType ??
+            'Image';
+        if (main_cjs.isDataType(dataType, main_cjs.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 = main_cjs.getStorageDirForDataType(dataType);
+        const filePath = `${baseDir}/${refResolvedValue}`;
+        const exists = await main_cjs.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 = main_cjs.BaseDb.getAppDb();
+    if (!appDb || options?.onlyHtmlStorageSeedLocalIds?.length)
+        return uploads;
+    const rows = await appDb
+        .select()
+        .from(main_cjs.htmlEmbeddedImageCoPublish)
+        .where(drizzleOrm.eq(main_cjs.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 main_cjs.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 = main_cjs.BaseDb.getAppDb();
+    const seedLocalId = childProperty.seedLocalId;
+    const propertyName = childProperty.storagePropertyName || childProperty.propertyName;
+    if (!appDb || !seedLocalId || !propertyName)
+        return undefined;
+    const where = [drizzleOrm.eq(main_cjs.metadata.seedLocalId, seedLocalId), drizzleOrm.eq(main_cjs.metadata.propertyName, propertyName)];
+    if (childProperty.versionLocalId)
+        where.push(drizzleOrm.eq(main_cjs.metadata.versionLocalId, childProperty.versionLocalId));
+    const rows = await appDb.select().from(main_cjs.metadata).where(drizzleOrm.and(...where));
+    return [...rows].sort(main_cjs.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 main_cjs.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 main_cjs.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 = main_cjs.getItemStorageSubdir(propertyDef?.localStorageDir || row?.localStorageDir);
+    if (row?.refResolvedValue) {
+        const fromRow = await tryPath(main_cjs.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 && main_cjs.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(main_cjs.BaseFileManager.getFilesPath(dir, main_cjs.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 } = main_cjs.resolveSeedIdsFromRefString(main_cjs.normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId) {
+            continue;
+        }
+        const dataType = itemProperty.propertyDef?.refValueType ??
+            itemProperty.propertyDef?.dataType ??
+            'Image';
+        const baseDir = main_cjs.getStorageDirForDataType(dataType);
+        const filePath = `${baseDir}/${refResolvedValue}`;
+        if (await main_cjs.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 main_cjs.BaseFileManager.pathExists(filePath);
+    }
+    return false;
+}
+async function itemOwnUploadCandidates(item, relatedItemProperty, recurseStorageRelations) {
+    const { itemUploadProperties, itemRelationProperties, itemImageProperties } = await publishDraftGraph.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 } = main_cjs.resolveSeedIdsFromRefString(main_cjs.normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId && !seedUid) {
+            throw new Error(`Invalid relation value for ${relationProperty.propertyName}: expected local seed id or 0x uid`);
+        }
+        const relatedItem = await main_cjs.Item.find({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            // Related seed referenced by attested uid with no local copy: already published, nothing to upload.
+            if (main_cjs.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 publishDraftGraph.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 main_cjs.BaseFileManager.pathExists(filePath);
+            if (!exists) {
+                return uploads;
+            }
+            try {
+                const read = await readUploadFile(filePath);
+                fileContents = read.bytes;
+                fileContentType = read.contentType;
+            }
+            catch (e) {
+                const fs = await main_cjs.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 main_cjs.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 publishDraftGraph.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 } = main_cjs.resolveSeedIdsFromRefString(main_cjs.normalizeRelationPropertyValue(propertyValue) ?? '');
+        if (!seedLocalId && !seedUid) {
+            throw new Error(`Invalid relation value for ${relationProperty.propertyName}: expected local seed id or 0x uid`);
+        }
+        const relatedItem = await main_cjs.Item.find({
+            seedLocalId,
+            seedUid,
+        });
+        if (!relatedItem) {
+            // Related seed referenced by attested uid with no local copy: already published, nothing to upload.
+            if (main_cjs.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 publishDraftGraph.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 arweave.BaseArweaveClient.createTransaction(upload.data, {
+            tags: upload.tags.length ? upload.tags : undefined,
+        }),
+    }));
+    uploads.push(...created);
+    return uploads;
+};
+
+exports.CREATE_TRANSACTION_CONCURRENCY = CREATE_TRANSACTION_CONCURRENCY;
+exports.getPublishUploadData = getPublishUploadData;
+exports.getPublishUploads = getPublishUploads;
+exports.itemHasPublishUploadCandidates = itemHasPublishUploadCandidates;
+exports.prepareArweaveTransaction = prepareArweaveTransaction;
+exports.resolveItemStorageChildFile = resolveItemStorageChildFile;
+//# sourceMappingURL=getPublishUploads-DsXY9S4U.js.map