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

package/dist/getPublishUploads-BBqiowVc.js

@@ -1,1080 +0,0 @@
-import { M as ModelPropertyDataTypes, Q as BaseFileManager, L as BaseDb, x as htmlEmbeddedImageCoPublish, r as resolveSeedIdsFromRefString, q as normalizeRelationPropertyValue, V as INTERNAL_STORAGE_MODEL_FILE_IDS, l as isPublishedSeedRef, i as isDataType, W as getStorageDirForDataType, X as getContentSha256, Y as buildArweaveContentTags, Z as getItemStorageSubdir, _ as getItemStorageLocalFileName, m as metadata } from './index-rOTW-2QZ.js';
-import { getPublicArweaveRawUrl, BaseArweaveClient } from '@seedprotocol/arweave';
-import { w as withItemLoads, g as getPublishDraftGraph, a as getSegmentedItemProperties } from './publishDraftGraph-DBWAN72w.js';
-import debug from 'debug';
-import { parseFragment } from 'parse5';
-import { eq, and } from 'drizzle-orm';
-import { n as getContentHash } from './ClientManager-DqL0q_eu.js';
-import { I as Item, F as waitForEntityIdle, y as compareMetadataRowsLatestFirst } from './Item-CG5IhPtL.js';
-import 'pluralize';
-import '@seedprotocol/eas';
-import { g as getExtensionForMimeType, r as resolveUploadMimeType } from './mimeTypes-C9r76DCH.js';
-
-const HTML_EMBEDDED_MAX_IMAGES_PER_DOC = 50;
-const HTML_EMBEDDED_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
-const HTML_EMBEDDED_MAX_TOTAL_BYTES = 25 * 1024 * 1024;
-const DATA_URI_IMAGE = /^data:(image\/[a-zA-Z0-9.+-]+);base64,([\s\S]*)$/i;
-const MIME_NORMALIZE = {
-    'image/jpg': 'image/jpeg',
-};
-function normalizeMime(m) {
-    const lower = m.toLowerCase().trim();
-    return MIME_NORMALIZE[lower] ?? lower;
-}
-const ALLOWED_MIMES = new Set([
-    'image/png',
-    'image/jpeg',
-    'image/webp',
-    'image/gif',
-    'image/svg+xml',
-]);
-class HtmlEmbeddedDataUriLimitError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'HtmlEmbeddedDataUriLimitError';
-    }
-}
-function resolveEffectiveHtmlEmbeddedDataUriPolicy(propertyDef, publishLevel) {
-    const fromProp = propertyDef?.htmlEmbeddedDataUriPolicy;
-    if (fromProp === 'materialize' || fromProp === 'preserve')
-        return fromProp;
-    if (publishLevel === 'materialize' || publishLevel === 'preserve')
-        return publishLevel;
-    return 'materialize';
-}
-function getAttr(node, name) {
-    const a = node.attrs?.find((x) => x.name === name);
-    return a?.value;
-}
-/**
- * Walk fragment tree; collect unique data:image base64 URIs with limits.
- */
-async function extractDataUriImagesFromHtml(html) {
-    const fragment = parseFragment(html);
-    const found = [];
-    const seenUris = new Set();
-    let totalBytes = 0;
-    const walk = async (node) => {
-        if (node.nodeName === '#text' || node.nodeName === '#comment')
-            return;
-        const el = node;
-        if (el.tagName === 'img') {
-            const src = getAttr(el, 'src')?.trim();
-            if (src && src.startsWith('data:image/')) {
-                const m = DATA_URI_IMAGE.exec(src);
-                if (m) {
-                    const mimeRaw = normalizeMime(m[1]);
-                    if (!ALLOWED_MIMES.has(mimeRaw)) {
-                        throw new HtmlEmbeddedDataUriLimitError(`Unsupported embedded image type: ${mimeRaw}. Allowed: ${[...ALLOWED_MIMES].join(', ')}`);
-                    }
-                    let binary;
-                    try {
-                        const b64 = m[2].replace(/\s/g, '');
-                        binary = Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
-                    }
-                    catch {
-                        throw new HtmlEmbeddedDataUriLimitError('Invalid base64 in embedded image data URI');
-                    }
-                    const byteLength = binary.byteLength;
-                    if (byteLength > HTML_EMBEDDED_MAX_IMAGE_BYTES) {
-                        throw new HtmlEmbeddedDataUriLimitError(`Embedded image exceeds max size (${HTML_EMBEDDED_MAX_IMAGE_BYTES} bytes)`);
-                    }
-                    totalBytes += byteLength;
-                    if (totalBytes > HTML_EMBEDDED_MAX_TOTAL_BYTES) {
-                        throw new HtmlEmbeddedDataUriLimitError(`Total embedded image size exceeds max (${HTML_EMBEDDED_MAX_TOTAL_BYTES} bytes)`);
-                    }
-                    if (!seenUris.has(src)) {
-                        if (seenUris.size >= HTML_EMBEDDED_MAX_IMAGES_PER_DOC) {
-                            throw new HtmlEmbeddedDataUriLimitError(`Too many distinct embedded images (max ${HTML_EMBEDDED_MAX_IMAGES_PER_DOC})`);
-                        }
-                        seenUris.add(src);
-                        const stableKey = await getContentHash(binary);
-                        found.push({ dataUri: src, stableKey, byteLength, mimeType: mimeRaw, bytes: binary });
-                    }
-                }
-            }
-        }
-        const parent = el;
-        if (parent.childNodes) {
-            for (const c of parent.childNodes)
-                await walk(c);
-        }
-    };
-    for (const c of fragment.childNodes)
-        await walk(c);
-    return found;
-}
-function escapeAttributeValue(value) {
-    return value.replace(/&/g, '&').replace(/"/g, '"');
-}
-/**
- * Rewrite attribute values of `html` by splicing each new value into the original string: every
- * byte other than the rewritten attributes stays as written. Re-serializing the parsed tree would
- * not round-trip (parse5 drops the newline the parser eats after `<pre>`/`<textarea>`/`<listing>`,
- * a fragment parse drops doctype/html/head/body, and quoting, case and line endings are normalized),
- * and sealed Html must not change with the serializer.
- *
- * `rewrite` gets each attribute's (entity-decoded) value and returns its new value, or undefined to
- * leave it. A rewritten attribute is written as `name="value"`.
- */
-function rewriteHtmlAttributes(html, rewrite) {
-    const fragment = parseFragment(html, { sourceCodeLocationInfo: true });
-    const edits = [];
-    const walk = (node) => {
-        if (node.nodeName === '#text' || node.nodeName === '#comment')
-            return;
-        const el = node;
-        if (el.attrs?.length) {
-            for (const attr of el.attrs) {
-                if (attr.prefix)
-                    continue;
-                const next = rewrite(el, attr.name, attr.value);
-                const location = el.sourceCodeLocation?.attrs?.[attr.name];
-                if (next === undefined || !location)
-                    continue;
-                edits.push({
-                    start: location.startOffset,
-                    end: location.endOffset,
-                    text: `${attr.name}="${escapeAttributeValue(next)}"`,
-                });
-            }
-        }
-        const parent = el;
-        if (parent.childNodes) {
-            for (const c of parent.childNodes)
-                walk(c);
-        }
-    };
-    for (const c of fragment.childNodes)
-        walk(c);
-    let out = html;
-    for (const edit of edits.sort((a, b) => b.start - a.start)) {
-        out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
-    }
-    return out;
-}
-/**
- * Replace `data:image/...` `<img src>` values with Arweave URLs (keyed by data URI). Only those
- * `src` attributes change; the rest of the Html is kept byte for byte.
- */
-function replaceDataUrisInParsedHtml(html, replacements) {
-    if (replacements.size === 0)
-        return html;
-    return rewriteHtmlAttributes(html, (el, attrName, value) => {
-        if (el.tagName !== 'img' || attrName !== 'src')
-            return undefined;
-        return replacements.get(value.trim());
-    });
-}
-/**
- * `seed:property/<propertyName>` in Html stands for the Arweave URL of the same item's
- * `<propertyName>` storage property (Image, File or Json). Publish uploads that property first,
- * then rewrites the placeholder to its gateway URL before the Html is uploaded, so Html can show a
- * file published alongside it without embedding it (e.g. `<img class="u-featured"
- * src="seed:property/featureImage">`).
- */
-const SEED_PROPERTY_REF_PREFIX = 'seed:property/';
-const SEED_PROPERTY_REF = /^seed:property\/([A-Za-z_$][A-Za-z0-9_$]*)$/;
-/** Attributes whose whole (trimmed) value may be a `seed:property/` placeholder. */
-const SEED_PROPERTY_REF_ATTRIBUTES = new Set(['src', 'href', 'poster']);
-const seedPropertyRefName = (attrName, value) => SEED_PROPERTY_REF_ATTRIBUTES.has(attrName) ? SEED_PROPERTY_REF.exec(value.trim())?.[1] : undefined;
-/** A `seed:property/` placeholder that names no usable property, or whose upload is unknown. */
-class HtmlSeedPropertyRefError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'HtmlSeedPropertyRefError';
-    }
-}
-/** Property names referenced by `seed:property/<name>` placeholders in `html`, each once. */
-function findSeedPropertyRefsInHtml(html) {
-    if (!html.includes(SEED_PROPERTY_REF_PREFIX))
-        return [];
-    const names = new Set();
-    rewriteHtmlAttributes(html, (_el, attrName, value) => {
-        const name = seedPropertyRefName(attrName, value);
-        if (name)
-            names.add(name);
-        return undefined;
-    });
-    return [...names];
-}
-/** Replace `seed:property/<name>` placeholders with `urlByPropertyName.get(name)`; other bytes are kept. */
-function replaceSeedPropertyRefsInHtml(html, urlByPropertyName) {
-    if (urlByPropertyName.size === 0)
-        return html;
-    return rewriteHtmlAttributes(html, (_el, attrName, value) => {
-        const name = seedPropertyRefName(attrName, value);
-        return name ? urlByPropertyName.get(name) : undefined;
-    });
-}
-const SEED_PROPERTY_REF_DATA_TYPES = [
-    ModelPropertyDataTypes.Image,
-    ModelPropertyDataTypes.File,
-    ModelPropertyDataTypes.Json,
-];
-/**
- * The storage property of `item` a `seed:property/<name>` placeholder names, and the seed it holds.
- * Html properties are refused: an Html seed may itself be deferred to after the rewrite.
- */
-function resolveSeedPropertyRefTarget(item, propertyName) {
-    const property = item.properties.find((p) => p.propertyName === propertyName || p.propertyName === `${propertyName}Id`);
-    const def = property?.propertyDef;
-    if (!property || !def) {
-        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${item.modelName} has no property ${propertyName}`);
-    }
-    const dataType = normalizeDataTypeLocal(def.dataType);
-    const storageType = dataType === ModelPropertyDataTypes.Relation ? normalizeDataTypeLocal(def.refValueType) : dataType;
-    if (!SEED_PROPERTY_REF_DATA_TYPES.includes(storageType)) {
-        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} is ${def.dataType}; ` +
-            `only Image, File and Json properties can be referenced`);
-    }
-    const snap = property.getService().getSnapshot();
-    const ctx = 'context' in snap ? snap.context : null;
-    const ids = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(ctx?.propertyValue) ?? '');
-    if (!ids.seedLocalId && !ids.seedUid) {
-        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} has no value`);
-    }
-    return ids;
-}
-const ARWEAVE_TX_ID = /^[a-z0-9_-]{43}$/i;
-/**
- * The Arweave tx of the storage seed a placeholder names: uploaded in this publish's phase 1, or,
- * when not uploaded now, the transaction it was published with (its storageTransactionId).
- */
-async function resolveSeedPropertyRefTxId(item, propertyName, txBySeedLocalId, loads) {
-    const { seedLocalId, seedUid } = resolveSeedPropertyRefTarget(item, propertyName);
-    const uploaded = seedLocalId ? txBySeedLocalId.get(seedLocalId) : undefined;
-    if (uploaded)
-        return uploaded;
-    const storageItem = await loads.find({ seedLocalId, seedUid });
-    const st = storageItem?.internalProperties['storageTransactionId'] ??
-        storageItem?.allProperties['storageTransactionId'];
-    const stSnap = st?.getService().getSnapshot();
-    const stValue = stSnap && 'context' in stSnap ? stSnap.context.propertyValue : undefined;
-    if (typeof stValue === 'string' && ARWEAVE_TX_ID.test(stValue.trim()))
-        return stValue.trim();
-    throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} was not uploaded ` +
-        `in this publish and has no published transaction`);
-}
-async function deleteCoPublishRowsForParent(appDb, parentSeedLocalId) {
-    if (!appDb)
-        return;
-    await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId));
-}
-/**
- * Name of the file holding an embedded image's bytes in the images folder: `<imageSeedLocalId>.<ext>`,
- * the extension following the image's MIME type (one of {@link ALLOWED_MIMES}).
- */
-function embeddedImageFileName(imageSeedLocalId, mimeType) {
-    return `${imageSeedLocalId}.${getExtensionForMimeType(mimeType) ?? 'bin'}`;
-}
-/** Path of the file {@link createImageItemFromBytes} wrote for an Image seed, or undefined if there is none. */
-async function findEmbeddedImageFilePath(imageSeedLocalId) {
-    for (const mimeType of ALLOWED_MIMES) {
-        const filePath = BaseFileManager.getFilesPath('images', embeddedImageFileName(imageSeedLocalId, mimeType));
-        if (await BaseFileManager.pathExists(filePath))
-            return filePath;
-    }
-    return undefined;
-}
-/**
- * Create an Image item for an embedded image and write its bytes to the images folder, where publish
- * reads them for upload ({@link findEmbeddedImageFilePath}). Its storageTransactionId stays empty
- * until the upload writes the transaction id, as for any other storage seed.
- */
-async function createImageItemFromBytes(bytes, mimeType) {
-    const imageItem = await Item.create({
-        modelName: 'Image',
-        modelFileId: INTERNAL_STORAGE_MODEL_FILE_IDS.image,
-    });
-    await waitForEntityIdle(imageItem, { timeout: 60000 });
-    const filePath = BaseFileManager.getFilesPath('images', embeddedImageFileName(imageItem.seedLocalId, mimeType));
-    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
-    const data = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-    try {
-        await BaseFileManager.saveFile(filePath, data);
-    }
-    catch {
-        const fs = await BaseFileManager.getFs();
-        fs.writeFileSync(filePath, bytes);
-    }
-    const { seedLocalId } = imageItem;
-    // Publish loads the image again when it uploads and attests it
-    imageItem.unload();
-    return { seedLocalId };
-}
-/**
- * Scan Html storage properties, materialize embedded images as Image items, insert co-publish rows.
- * Call before phase-1 Arweave tx build. Does not rewrite Html files yet.
- */
-async function prepareHtmlEmbeddedImagesForPublish(item, publishPolicy) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb) {
-        return { deferredHtmlSeedLocalIds: [] };
-    }
-    const deferred = new Set();
-    // The item's own Html, and the Html of the draft items published with it: each gets its embedded
-    // images materialized and co-published (rows keyed by the item owning the Html property).
-    await withItemLoads(undefined, async (loads) => {
-        for (const parent of [item, ...(await getRelatedDraftsCoPublishedWith(item, loads))]) {
-            await prepareHtmlEmbeddedImagesOfItem(appDb, parent, publishPolicy, deferred);
-        }
-    });
-    return { deferredHtmlSeedLocalIds: [...deferred] };
-}
-/**
- * Draft items (no seed uid yet) that a publish of `item` publishes with it: every draft reachable
- * through relation and list properties, as getPublishPayload and getPublishUploads walk them
- * (publishDraftGraph.ts). Html-embedded images of these items are co-published with `item` like its own.
- */
-async function getRelatedDraftsCoPublishedWith(item, loads) {
-    const _mod_0 = await import('./publishDraftGraph-DBWAN72w.js');
-    const _ns_0 = _mod_0.p;
-    const { getPublishDraftGraph } = _ns_0;
-    const { drafts } = await getPublishDraftGraph(item, { loads });
-    return drafts.map((d) => d.item);
-}
-async function prepareHtmlEmbeddedImagesOfItem(appDb, item, publishPolicy, deferred) {
-    await deleteCoPublishRowsForParent(appDb, item.seedLocalId);
-    for (const p of item.properties) {
-        const def = p.propertyDef;
-        if (!def || normalizeDataTypeLocal(def.dataType) !== ModelPropertyDataTypes.Html)
-            continue;
-        const snap = p.getService().getSnapshot();
-        const ctx = 'context' in snap ? snap.context : null;
-        const htmlSeedLocalId = typeof ctx?.propertyValue === 'string' ? ctx.propertyValue : '';
-        const refResolved = ctx?.refResolvedValue;
-        if (!htmlSeedLocalId?.trim() || !refResolved)
-            continue;
-        const filePath = `${BaseFileManager.getFilesPath('html')}/${refResolved}`;
-        const exists = await BaseFileManager.pathExists(filePath);
-        if (!exists)
-            continue;
-        let html;
-        try {
-            html = await BaseFileManager.readFileAsString(filePath);
-        }
-        catch {
-            const buf = await BaseFileManager.readFileAsBuffer(filePath);
-            if (typeof Buffer !== 'undefined' && Buffer.isBuffer(buf)) {
-                html = buf.toString('utf-8');
-            }
-            else if (typeof Blob !== 'undefined' && buf instanceof Blob) {
-                html = await buf.text();
-            }
-            else if (buf instanceof ArrayBuffer) {
-                html = new TextDecoder('utf-8', { fatal: false }).decode(buf);
-            }
-            else {
-                const v = buf;
-                html = new TextDecoder('utf-8', { fatal: false }).decode(new Uint8Array(v.buffer, v.byteOffset, v.byteLength));
-            }
-        }
-        // seed:property/ placeholders are filled in after phase 1 whatever the data URI policy. A
-        // placeholder naming no usable property fails here, before anything is uploaded.
-        const refs = findSeedPropertyRefsInHtml(html);
-        for (const name of refs)
-            resolveSeedPropertyRefTarget(item, name);
-        if (refs.length > 0)
-            deferred.add(htmlSeedLocalId.trim());
-        const policy = resolveEffectiveHtmlEmbeddedDataUriPolicy(def, publishPolicy);
-        if (policy !== 'materialize')
-            continue;
-        const extracted = await extractDataUriImagesFromHtml(html);
-        if (extracted.length === 0)
-            continue;
-        deferred.add(htmlSeedLocalId.trim());
-        for (const ent of extracted) {
-            const { seedLocalId: imageSeedLocalId } = await createImageItemFromBytes(ent.bytes, ent.mimeType);
-            const now = Date.now();
-            await appDb.insert(htmlEmbeddedImageCoPublish).values({
-                parentSeedLocalId: item.seedLocalId,
-                htmlSeedLocalId: htmlSeedLocalId.trim(),
-                imageSeedLocalId,
-                stableKey: ent.stableKey,
-                createdAt: now,
-            }).onConflictDoNothing();
-        }
-    }
-}
-function normalizeDataTypeLocal(dt) {
-    if (!dt)
-        return '';
-    return dt.charAt(0).toUpperCase() + dt.slice(1).toLowerCase();
-}
-/**
- * After phase-1 uploads, rewrite Html files on disk: data URI → Arweave gateway URL, and
- * `seed:property/<name>` → the gateway URL of that property's upload.
- *
- * `deferredHtmlSeedLocalIds` (from {@link prepareHtmlEmbeddedImagesForPublish}) limits the rewrite to
- * the Html held back from phase 1; without it, every Html of the item and its co-published drafts is
- * considered.
- */
-async function rewriteHtmlEmbeddedImagesOnDisk(parentSeedLocalId, uploadedTransactions, deferredHtmlSeedLocalIds) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return;
-    await withItemLoads(undefined, async (loads) => {
-        const parentItem = await loads.find({ seedLocalId: parentSeedLocalId });
-        if (!parentItem)
-            return;
-        await rewriteHtmlEmbeddedImagesOfItemAndDrafts(appDb, parentItem, uploadedTransactions, deferredHtmlSeedLocalIds, loads);
-    });
-}
-async function rewriteHtmlEmbeddedImagesOfItemAndDrafts(appDb, parentItem, uploadedTransactions, deferredHtmlSeedLocalIds, loads) {
-    const txBySeedLocalId = new Map();
-    for (const u of uploadedTransactions) {
-        if (u.seedLocalId && u.txId) {
-            txBySeedLocalId.set(u.seedLocalId.trim(), u.txId.trim());
-        }
-    }
-    const deferred = deferredHtmlSeedLocalIds
-        ? new Set(deferredHtmlSeedLocalIds.map((id) => id.trim()))
-        : undefined;
-    // The parent's Html and that of the draft items published with it (see prepareHtmlEmbeddedImagesForPublish).
-    for (const item of [parentItem, ...(await getRelatedDraftsCoPublishedWith(parentItem, loads))]) {
-        await rewriteHtmlEmbeddedImagesOfItem(appDb, item, txBySeedLocalId, deferred, loads);
-    }
-}
-async function rewriteHtmlEmbeddedImagesOfItem(appDb, parentItem, txBySeedLocalId, deferred, loads) {
-    const rows = await appDb
-        .select()
-        .from(htmlEmbeddedImageCoPublish)
-        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentItem.seedLocalId));
-    for (const p of parentItem.properties) {
-        const def = p.propertyDef;
-        if (!def || normalizeDataTypeLocal(def.dataType) !== ModelPropertyDataTypes.Html)
-            continue;
-        const snap = p.getService().getSnapshot();
-        const ctx = 'context' in snap ? snap.context : null;
-        const htmlSeedLocalId = typeof ctx?.propertyValue === 'string' ? ctx.propertyValue.trim() : '';
-        const refResolved = ctx?.refResolvedValue;
-        if (!htmlSeedLocalId || !refResolved)
-            continue;
-        if (deferred && !deferred.has(htmlSeedLocalId))
-            continue;
-        const htmlRows = rows.filter((r) => String(r.htmlSeedLocalId).trim() === htmlSeedLocalId);
-        const filePath = `${BaseFileManager.getFilesPath('html')}/${refResolved}`;
-        if (!(await BaseFileManager.pathExists(filePath)))
-            continue;
-        const html = await BaseFileManager.readFileAsString(filePath);
-        const replacements = new Map();
-        for (const r of htmlRows) {
-            const txId = txBySeedLocalId.get(r.imageSeedLocalId.trim());
-            if (!txId)
-                continue;
-            const dataUri = await findDataUriForStableKey(html, r.stableKey);
-            if (dataUri)
-                replacements.set(dataUri, getPublicArweaveRawUrl(txId));
-        }
-        const urlByPropertyName = new Map();
-        for (const name of findSeedPropertyRefsInHtml(html)) {
-            const txId = await resolveSeedPropertyRefTxId(parentItem, name, txBySeedLocalId, loads);
-            urlByPropertyName.set(name, getPublicArweaveRawUrl(txId));
-        }
-        const newHtml = replaceSeedPropertyRefsInHtml(replaceDataUrisInParsedHtml(html, replacements), urlByPropertyName);
-        if (newHtml === html)
-            continue;
-        try {
-            await BaseFileManager.saveFile(filePath, newHtml);
-        }
-        catch {
-            const fs = await BaseFileManager.getFs();
-            fs.writeFileSync(filePath, newHtml);
-        }
-        p.getService().send({
-            type: 'updateContext',
-            renderValue: newHtml,
-        });
-    }
-}
-async function findDataUriForStableKey(html, stableKey) {
-    const entries = await extractDataUriImagesFromHtml(html);
-    const hit = entries.find((e) => e.stableKey === stableKey);
-    return hit?.dataUri;
-}
-/**
- * Remove co-publish rows after a successful publish for this parent seed.
- */
-async function clearHtmlEmbeddedImageCoPublishRows(parentSeedLocalId) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb || !parentSeedLocalId)
-        return;
-    await appDb
-        .delete(htmlEmbeddedImageCoPublish)
-        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId.trim()));
-}
-
-/**
- * `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 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, loads, 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 loads.find({ seedLocalId: row.imageSeedLocalId, modelName: 'Image' });
-        if (!imageItem)
-            continue;
-        const st = imageItem.internalProperties['storageTransactionId'] ??
-            imageItem.allProperties['storageTransactionId'];
-        const filePath = await findEmbeddedImageFilePath(imageItem.seedLocalId);
-        const more = [];
-        if (filePath && st && st.localId && st.versionLocalId) {
-            const { bytes, contentType } = await readUploadFile(filePath);
-            more.push(buildPublishUploadData(bytes, contentType, {
-                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];
-};
-/**
- * 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, 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;
-    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, loads) {
-    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 loads.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, loads)) {
-            return true;
-        }
-    }
-    return false;
-}
-/** Same walk as getPublishUploads: the item and the draft items its publish carries along. */
-async function itemHasPublishUploadCandidates(item, relatedItemProperty) {
-    return withItemLoads(undefined, async (loads) => {
-        if (await itemOwnUploadCandidates(item, relatedItemProperty, true, loads))
-            return true;
-        const { drafts } = await getPublishDraftGraph(item, { strict: true, loads });
-        for (const { item: draft, via, viaList } of drafts) {
-            if (await itemOwnUploadCandidates(draft, viaList ? undefined : via, true, loads))
-                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 {
-                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 {
-                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';
-    }
-    const itemPropertyLocalId = relatedItemProperty
-        ? relatedItemProperty.localId
-        : itemProperty.localId;
-    const 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, loads) => {
-    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, loads, 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 loads.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 }, loads);
-    }
-    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) => {
-    return withItemLoads(undefined, async (loads) => {
-        uploads = await getItemOwnPublishUploadData(item, uploads, relatedItemProperty, options, loads);
-        if (options?.skipRelationRecursion) {
-            return uploads;
-        }
-        const { drafts } = await getPublishDraftGraph(item, { strict: true, loads });
-        for (const { item: draft, via, viaList } of drafts) {
-            uploads = await getItemOwnPublishUploadData(draft, uploads, viaList ? undefined : via, options, loads);
-        }
-        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) => {
-    // Every edit made before publishing is in `metadata` and its files first (ADR 0019)
-    const { waitForPendingOutboxOps } = await import('./index-njjjo74v.js');
-    await waitForPendingOutboxOps();
-    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;
-};
-
-var getPublishUploads$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    CREATE_TRANSACTION_CONCURRENCY: CREATE_TRANSACTION_CONCURRENCY,
-    getPublishUploadData: getPublishUploadData,
-    getPublishUploads: getPublishUploads,
-    itemHasPublishUploadCandidates: itemHasPublishUploadCandidates,
-    resolveItemStorageChildFile: resolveItemStorageChildFile
-});
-
-export { HTML_EMBEDDED_MAX_IMAGES_PER_DOC as H, SEED_PROPERTY_REF_PREFIX as S, HTML_EMBEDDED_MAX_IMAGE_BYTES as a, HTML_EMBEDDED_MAX_TOTAL_BYTES as b, HtmlEmbeddedDataUriLimitError as c, HtmlSeedPropertyRefError as d, clearHtmlEmbeddedImageCoPublishRows as e, findEmbeddedImageFilePath as f, getRelatedDraftsCoPublishedWith as g, extractDataUriImagesFromHtml as h, findSeedPropertyRefsInHtml as i, getPublishUploadData as j, itemHasPublishUploadCandidates as k, replaceSeedPropertyRefsInHtml as l, resolveEffectiveHtmlEmbeddedDataUriPolicy as m, rewriteHtmlEmbeddedImagesOnDisk as n, getPublishUploads$1 as o, prepareHtmlEmbeddedImagesForPublish as p, replaceDataUrisInParsedHtml as r };
-//# sourceMappingURL=getPublishUploads-BBqiowVc.js.map