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

package/dist/getPublishUploads-sS6JfPgz.js

@@ -0,0 +1,783 @@
+import { getPublicArweaveRawUrl, resolveSeedIdsFromRefString, normalizeRelationPropertyValue, BaseArweaveClient } from '@seedprotocol/arweave';
+import { w as BaseFileManager, B as BaseDb, h as htmlEmbeddedImageCoPublish } from './BaseFileManager-BAlySv8w.js';
+import 'pluralize';
+import { isValidEasAttestationUid } from '@seedprotocol/eas';
+import { R as getExtensionForMimeType, M as ModelPropertyDataTypes, n as normalizeDataType, j as findSeedRow, U as INTERNAL_STORAGE_MODEL_FILE_IDS, i as isDataType, V as resolveUploadMimeType, W as getContentSha256, X as buildArweaveContentTags, Y as getItemStorageSubdir, _ as getItemStorageLocalFileName } from './tabEvents-CaVmngqr.js';
+import { eq } from 'drizzle-orm';
+import { I as Item, _ as waitForEntityReady, ac as storageSeedTransactionId, ad as storageUploadPath } from './Item-Bf4kWKpH.js';
+import debug from 'debug';
+import { parseFragment } from 'parse5';
+import { E as getContentHash } from './errors-DLSoqSHG.js';
+import { g as getPublishGraph, p as publishGraphItemNodes } from './publishGraph-EcB40Uii.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 `node` 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(node, propertyName) {
+    const property = node.properties.find((p) => p.key === propertyName);
+    if (!property) {
+        throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${node.modelName} has no property ${propertyName}`);
+    }
+    const def = property.definition;
+    const dataType = normalizeDataType(def.dataType);
+    const storageType = dataType === ModelPropertyDataTypes.Relation ? normalizeDataType(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 ids = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(property.row?.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 row).
+ */
+async function resolveSeedPropertyRefTxId(node, propertyName, txBySeedLocalId) {
+    const target = resolveSeedPropertyRefTarget(node, propertyName);
+    const uploaded = target.seedLocalId ? txBySeedLocalId.get(target.seedLocalId) : undefined;
+    if (uploaded)
+        return uploaded;
+    const recorded = await storageSeedTransactionId(target);
+    if (recorded && ARWEAVE_TX_ID.test(recorded))
+        return recorded;
+    throw new HtmlSeedPropertyRefError(`Html references ${SEED_PROPERTY_REF_PREFIX}${propertyName}, but ${propertyName} was not uploaded ` +
+        `in this publish and has no published transaction`);
+}
+/**
+ * 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 waitForEntityReady(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 reads the image from its rows when it uploads and attests it
+    imageItem.unload();
+    return { seedLocalId };
+}
+/** The Html properties of a node with a stored Html seed and file name. */
+const htmlValuesOf = (node) => node.properties.flatMap((property) => {
+    if (normalizeDataType(property.definition.dataType) !== ModelPropertyDataTypes.Html)
+        return [];
+    const htmlSeedLocalId = property.row?.propertyValue?.trim();
+    const fileName = property.row?.refResolvedValue;
+    return htmlSeedLocalId && fileName ? [{ property, htmlSeedLocalId, filePath: `${BaseFileManager.getFilesPath('html')}/${fileName}` }] : [];
+});
+/**
+ * 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).
+    const graph = await getPublishGraph(item);
+    for (const node of publishGraphItemNodes(graph)) {
+        await prepareHtmlEmbeddedImagesOfNode(appDb, node, publishPolicy, deferred);
+    }
+    return { deferredHtmlSeedLocalIds: [...deferred] };
+}
+/**
+ * An embedded image an earlier attempt materialized for this data URI that can be used again: its
+ * Image seed is still a local draft and its file is there.
+ */
+async function reusableImage(row) {
+    if (!row)
+        return undefined;
+    const seed = await findSeedRow({ localId: row.imageSeedLocalId });
+    if (!seed || isValidEasAttestationUid(seed.uid))
+        return undefined;
+    return (await findEmbeddedImageFilePath(row.imageSeedLocalId)) ? row.imageSeedLocalId : undefined;
+}
+async function prepareHtmlEmbeddedImagesOfNode(appDb, node, publishPolicy, deferred) {
+    // An earlier attempt's rows: their images are reused for the same Html and data URI
+    const earlier = node.embeddedImages;
+    const kept = [];
+    for (const { property, htmlSeedLocalId, filePath } of htmlValuesOf(node)) {
+        if (!(await BaseFileManager.pathExists(filePath)))
+            continue;
+        const html = await BaseFileManager.readFileAsString(filePath);
+        // 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(node, name);
+        if (refs.length > 0)
+            deferred.add(htmlSeedLocalId);
+        // The policy is the row's definition (a schema file's htmlEmbeddedDataUriPolicy or a code-defined one)
+        const policy = resolveEffectiveHtmlEmbeddedDataUriPolicy(property.definition, publishPolicy);
+        if (policy !== 'materialize')
+            continue;
+        const extracted = await extractDataUriImagesFromHtml(html);
+        if (extracted.length === 0)
+            continue;
+        deferred.add(htmlSeedLocalId);
+        for (const ent of extracted) {
+            const previous = earlier.find((r) => r.htmlSeedLocalId.trim() === htmlSeedLocalId && r.stableKey === ent.stableKey);
+            const reused = await reusableImage(previous);
+            if (reused) {
+                kept.push(previous);
+                continue;
+            }
+            const { seedLocalId: imageSeedLocalId } = await createImageItemFromBytes(ent.bytes, ent.mimeType);
+            if (previous)
+                await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.id, previous.id));
+            await appDb.insert(htmlEmbeddedImageCoPublish).values({
+                parentSeedLocalId: node.seedLocalId,
+                htmlSeedLocalId,
+                imageSeedLocalId,
+                stableKey: ent.stableKey,
+                createdAt: Date.now(),
+            }).onConflictDoNothing();
+        }
+    }
+    // Rows for Html or data URIs no longer there
+    for (const row of earlier) {
+        if (kept.includes(row))
+            continue;
+        await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.id, row.id));
+    }
+}
+/**
+ * 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;
+    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).
+    const graph = await getPublishGraph({ seedLocalId: parentSeedLocalId });
+    for (const node of publishGraphItemNodes(graph)) {
+        await rewriteHtmlEmbeddedImagesOfNode(node, txBySeedLocalId, deferred);
+    }
+}
+async function rewriteHtmlEmbeddedImagesOfNode(node, txBySeedLocalId, deferred) {
+    for (const { htmlSeedLocalId, filePath } of htmlValuesOf(node)) {
+        if (deferred && !deferred.has(htmlSeedLocalId))
+            continue;
+        if (!(await BaseFileManager.pathExists(filePath)))
+            continue;
+        const html = await BaseFileManager.readFileAsString(filePath);
+        const replacements = new Map();
+        const entries = await extractDataUriImagesFromHtml(html);
+        for (const r of node.embeddedImages) {
+            if (r.htmlSeedLocalId.trim() !== htmlSeedLocalId)
+                continue;
+            const txId = txBySeedLocalId.get(r.imageSeedLocalId.trim());
+            const dataUri = entries.find((e) => e.stableKey === r.stableKey)?.dataUri;
+            if (txId && dataUri)
+                replacements.set(dataUri, getPublicArweaveRawUrl(txId));
+        }
+        const urlByPropertyName = new Map();
+        for (const name of findSeedPropertyRefsInHtml(html)) {
+            const txId = await resolveSeedPropertyRefTxId(node, name, txBySeedLocalId);
+            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);
+        }
+    }
+}
+/**
+ * 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 isUsablePath = (filePath) => !!filePath && !filePath.endsWith('undefined') && !filePath.endsWith('null');
+/**
+ * Local file of one ItemStorage property of a node. Tries, in order: its current 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 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.
+ */
+const resolveItemStorageChildFile = async (node, property) => {
+    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 { row, definition } = property;
+    const dir = getItemStorageSubdir(definition.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 seedIds = !row || isLocalDraft ? [row?.seedUid, node.seedUid, row?.seedLocalId, node.seedLocalId] : [];
+    for (const seedId of seedIds) {
+        if (!seedId)
+            continue;
+        const derived = await tryPath(BaseFileManager.getFilesPath(dir, getItemStorageLocalFileName(seedId, definition.filenameSuffix)));
+        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 } : {};
+};
+const slotOf = (node) => node.properties.find((p) => p.kind === 'storageTransaction');
+/** Where an upload attesting through `node`'s storageTransactionId is recorded. */
+const slotTarget = (node) => {
+    const slot = slotOf(node);
+    return {
+        seedLocalId: node.seedLocalId,
+        itemPropertyName: slot?.key ?? 'storageTransactionId',
+        itemPropertyLocalId: slot?.row?.localId ?? '',
+        versionLocalId: slot?.row?.versionLocalId ?? node.version.localId ?? '',
+    };
+};
+/** A node's own files: the ItemStorage properties beside its storageTransactionId, as one composite. */
+async function compositeSource(node) {
+    if (!slotOf(node))
+        return undefined;
+    const children = [];
+    const missingLocalEdits = [];
+    for (const property of node.properties) {
+        if (property.kind !== 'itemStorage')
+            continue;
+        const { filePath, missingLocalEdit } = await resolveItemStorageChildFile(node, property);
+        if (filePath)
+            children.push({ name: property.key, filePath });
+        else if (missingLocalEdit)
+            missingLocalEdits.push({ name: property.key, tried: missingLocalEdit });
+    }
+    if (children.length === 0 && missingLocalEdits.length === 0)
+        return undefined;
+    return { ...slotTarget(node), children, ...(missingLocalEdits.length ? { missingLocalEdits } : {}) };
+}
+/** The file of a storage seed this publish attests, named by the referring property's row. */
+async function storageSeedSource(owner, property) {
+    const target = property.refs[0]?.node;
+    const refResolvedValue = property.row?.refResolvedValue;
+    if (!target || !refResolvedValue)
+        return undefined;
+    const filePath = storageUploadPath({
+        dataType: property.definition.refValueType ?? property.definition.dataType,
+        refResolvedValue,
+        localStorageDir: property.row?.localStorageDir,
+    });
+    if (!(await BaseFileManager.pathExists(filePath)))
+        return undefined;
+    return {
+        seedLocalId: target.seedLocalId,
+        itemPropertyName: property.key,
+        itemPropertyLocalId: property.row?.localId ?? '',
+        versionLocalId: property.row?.versionLocalId ?? owner.version.localId ?? '',
+        filePath,
+    };
+}
+const isHtmlStorageProperty = (property) => isDataType(property.definition.refValueType ?? property.definition.dataType, ModelPropertyDataTypes.Html);
+/**
+ * Every upload a publish makes, in graph order (the root's first), one per attesting seed. The
+ * options select the phases of a publish with Html-embedded images: phase 1 defers the listed Html
+ * storage seeds, phase 2 uploads only those.
+ */
+async function getPublishUploadSources(graph, options) {
+    const onlyHtml = options?.onlyHtmlStorageSeedLocalIds?.length ? new Set(options.onlyHtmlStorageSeedLocalIds) : undefined;
+    const deferHtml = new Set(options?.deferHtmlStorageSeedLocalIds ?? []);
+    const sources = [];
+    const add = (source) => {
+        if (source && !sources.some((s) => s.seedLocalId === source.seedLocalId))
+            sources.push(source);
+    };
+    for (const node of [graph.root, ...graph.nodes.filter((n) => n !== graph.root)]) {
+        if (!onlyHtml)
+            add(await compositeSource(node));
+        if (node.kind !== 'root' && node.kind !== 'draft')
+            continue;
+        for (const property of node.properties) {
+            if (property.kind !== 'storageSeed' || property.deferred)
+                continue;
+            const seedLocalId = property.refs[0]?.node?.seedLocalId;
+            if (!seedLocalId)
+                continue;
+            if (isHtmlStorageProperty(property) ? deferHtml.has(seedLocalId) || (onlyHtml && !onlyHtml.has(seedLocalId)) : onlyHtml)
+                continue;
+            add(await storageSeedSource(node, property));
+        }
+        if (onlyHtml)
+            continue;
+        for (const row of node.embeddedImages) {
+            const image = graph.nodes.find((n) => n.seedLocalId === row.imageSeedLocalId && n.kind === 'embeddedImage');
+            const filePath = image ? await findEmbeddedImageFilePath(image.seedLocalId) : undefined;
+            if (image && filePath)
+                add({ ...slotTarget(image), filePath });
+        }
+    }
+    return sources;
+}
+/** The bytes of one source; a missing local ItemStorage edit fails the publish. */
+async function readSource(source, options) {
+    const { filePath, children, missingLocalEdits, ...target } = source;
+    const missing = missingLocalEdits?.[0];
+    if (missing) {
+        // Uploading without it would publish a composite that silently lacks this edit.
+        throw new Error(`Cannot publish ${source.seedLocalId}: the local file for ${missing.name} ` +
+            `was not found (looked in ${missing.tried.join(', ')})`);
+    }
+    if (children) {
+        // Composite of the node'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 parts = [];
+        for (const child of children)
+            parts.push({ name: child.name, bytes: (await readUploadFile(child.filePath)).bytes });
+        return buildPublishUploadData(encodeCompositeUpload(parts), 'application/octet-stream', target, options);
+    }
+    const { bytes, contentType } = await readUploadFile(filePath);
+    return buildPublishUploadData(bytes, contentType, target, options);
+}
+/** Fails like a publish would when an item's relation names a seed that isn't there. */
+function assertRefsResolve(graph) {
+    for (const broken of graph.brokenRefs) {
+        if (broken.list)
+            continue;
+        throw new Error(broken.reason === 'invalid'
+            ? `Invalid relation value for ${broken.propertyKey}: expected local seed id or 0x uid`
+            : `No relatedItem found for ${broken.propertyKey}`);
+    }
+}
+/**
+ * True if publish would include at least one Arweave upload (local file / storage seed present,
+ * or a saved local edit whose file is missing, which the upload then reports). Reads rows and
+ * file metadata only, for routing (e.g. skip the Arweave steps).
+ */
+async function itemHasPublishUploadCandidates(item) {
+    const graph = await getPublishGraph(item);
+    assertRefsResolve(graph);
+    return (await getPublishUploadSources(graph)).length > 0;
+}
+/**
+ * Upload data for a publish of `item`: its own, and that of every seed the publish attests with it
+ * (see publishGraph.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, options) => {
+    const graph = await getPublishGraph(item);
+    assertRefsResolve(graph);
+    const sources = await getPublishUploadSources(graph, options);
+    logger('%d uploads for %s', sources.length, item.seedLocalId);
+    const uploads = [];
+    for (const source of sources)
+        uploads.push(await readSource(source, 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, options) => {
+    const uploadData = await getPublishUploadData(item, options);
+    // Each createTransaction fetches the price / anchor from the gateway: run a few at once.
+    return 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,
+        }),
+    }));
+};
+
+var getPublishUploads$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CREATE_TRANSACTION_CONCURRENCY: CREATE_TRANSACTION_CONCURRENCY,
+    getPublishUploadData: getPublishUploadData,
+    getPublishUploadSources: getPublishUploadSources,
+    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, extractDataUriImagesFromHtml as f, getPublishUploadSources as g, findSeedPropertyRefsInHtml as h, getPublishUploadData as i, itemHasPublishUploadCandidates as j, replaceSeedPropertyRefsInHtml as k, resolveEffectiveHtmlEmbeddedDataUriPolicy as l, rewriteHtmlEmbeddedImagesOnDisk as m, getPublishUploads$1 as n, prepareHtmlEmbeddedImagesForPublish as p, replaceDataUrisInParsedHtml as r };
+//# sourceMappingURL=getPublishUploads-sS6JfPgz.js.map