@seedprotocol/sdk 0.7.4 → 0.7.5-next.871.g8788c94

package/dist/{getPublishUploads-J-143iSV.js → getPublishUploads-pEOrXJbF.js}

@@ -1,28 +1,499 @@
-import { N as resolveSeedIdsFromRefString, O as normalizeRelationPropertyValue, Q as isPublishedSeedRef, i as isDataType, M as ModelPropertyDataTypes, R as getStorageDirForDataType, J as BaseFileManager, E as BaseDb, o as htmlEmbeddedImageCoPublish, S as getContentSha256, U as buildArweaveContentTags, V as getItemStorageSubdir, W as getItemStorageLocalFileName, m as metadata } from './BasePathResolver-DrzGVH9L.js';
+import { h as BaseFileManager, M as ModelPropertyDataTypes, B as BaseDb, p as htmlEmbeddedImageCoPublish, Z as getArweaveUrlForTransaction, W as resolveSeedIdsFromRefString, V as normalizeRelationPropertyValue, _ as INTERNAL_STORAGE_MODEL_FILE_IDS, U as isPublishedSeedRef, i as isDataType, $ as getStorageDirForDataType, a0 as getContentSha256, a1 as buildArweaveContentTags, a2 as getItemStorageSubdir, a3 as getItemStorageLocalFileName, m as metadata } from './BasePathResolver-B-fK7_N_.js';
 import { BaseArweaveClient } from '@seedprotocol/arweave';
-import { g as getPublishDraftGraph, a as getSegmentedItemProperties } from './publishDraftGraph-CuVq6iAR.js';
+import { g as getPublishDraftGraph, a as getSegmentedItemProperties } from './publishDraftGraph-DGhC9ifI.js';
 import debug from 'debug';
-import { I as Item, c as compareMetadataRowsLatestFirst } from './Item-BUUFuywT.js';
+import { I as Item, d as waitForEntityIdle, e as compareMetadataRowsLatestFirst } from './Item-BDmsdNTQ.js';
+import { parseFragment } from 'parse5';
 import { eq, and } from 'drizzle-orm';
+import { a as getContentHash, b as isVerbatimItemStorageDraftRow, c as convertVerbatimItemStorageRow } from './ClientManager-C7VkO5Hg.js';
 import 'pluralize';
 import '@seedprotocol/eas';
-import { r as resolveUploadMimeType } from './mimeTypes-DHAHC4eZ.js';
-import { i as isVerbatimItemStorageDraftRow, c as convertVerbatimItemStorageRow } from './ClientManager-Dfu4jcgm.js';
-import 'xstate';
-import '@sinclair/typebox';
-import 'drizzle-orm/sqlite-core';
-import 'nanoid';
-import 'nanoid-dictionary';
-import '@seedprotocol/query';
-import '@noble/hashes/sha256';
-import '@noble/hashes/sha3';
-import '@noble/hashes/utils';
-import 'lodash-es';
-import './errors-DdWbxb_n.js';
-import './model-oHA3YhOd.js';
-import './property-zFPMtR3T.js';
-import 'rxjs';
-import './tabEvents-nBUq_1u1.js';
+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) {
+    const { seedLocalId, seedUid } = resolveSeedPropertyRefTarget(item, propertyName);
+    const uploaded = seedLocalId ? txBySeedLocalId.get(seedLocalId) : undefined;
+    if (uploaded)
+        return uploaded;
+    const storageItem = await Item.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);
+    }
+    return { seedLocalId: imageItem.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).
+    for (const parent of [item, ...(await getRelatedDraftsCoPublishedWith(item))]) {
+        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) {
+    const _mod_0 = await import('./publishDraftGraph-DGhC9ifI.js');
+    const _ns_0 = _mod_0.p;
+    const { getPublishDraftGraph } = _ns_0;
+    const { drafts } = await getPublishDraftGraph(item);
+    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;
+    const parentItem = await Item.find({ seedLocalId: parentSeedLocalId });
+    if (!parentItem)
+        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).
+    for (const item of [parentItem, ...(await getRelatedDraftsCoPublishedWith(parentItem))]) {
+        await rewriteHtmlEmbeddedImagesOfItem(appDb, item, txBySeedLocalId, deferred);
+    }
+}
+async function rewriteHtmlEmbeddedImagesOfItem(appDb, parentItem, txBySeedLocalId, deferred) {
+    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, getArweaveUrlForTransaction(txId));
+        }
+        const urlByPropertyName = new Map();
+        for (const name of findSeedPropertyRefsInHtml(html)) {
+            const txId = await resolveSeedPropertyRefTxId(parentItem, name, txBySeedLocalId);
+            urlByPropertyName.set(name, getArweaveUrlForTransaction(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.
@@ -134,21 +605,6 @@ const buildPublishUploadData = (data, contentType, target, options) => {
         ...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) {
@@ -215,15 +671,11 @@ async function appendCoPublishedImageUploadData(item, uploads, options) {
             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 filePath = await findEmbeddedImageFilePath(imageItem.seedLocalId);
         const more = [];
-        if (decoded && st && st.localId && st.versionLocalId) {
-            more.push(buildPublishUploadData(decoded.bytes, decoded.mimeType, {
+        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,
@@ -643,5 +1095,14 @@ const getPublishUploads = async (item, uploads = [], relatedItemProperty, option
     return uploads;
 };
 
-export { CREATE_TRANSACTION_CONCURRENCY, getPublishUploadData, getPublishUploads, itemHasPublishUploadCandidates, resolveItemStorageChildFile };
-//# sourceMappingURL=getPublishUploads-J-143iSV.js.map
+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-pEOrXJbF.js.map