@seedprotocol/sdk 0.4.19 → 0.4.21

package/dist/main.js

@@ -1,14 +1,16 @@
 import 'reflect-metadata';
-import { o as BaseDb, A as versions, a6 as metadata, s as seeds, E as parseListPropertyValueFromStorage, q as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString } from './index-BvZCYMxA.js';
-export { w as BaseArweaveClient, u as BaseFileManager, aH as ClientManagerState, b1 as DEFAULT_ARWEAVE_GATEWAYS, b2 as DEFAULT_ARWEAVE_GRAPHQL_URL, b0 as DEFAULT_ARWEAVE_HOST, a1 as EasClient, u as FileManager, O as INTERNAL_DATA_TYPES, aP as ImageSize, t as Item, am as ItemProperty, aI as MachineIds, M as Model, b as ModelPropertyDataTypes, aO as SEED_PROTOCOL_SCHEMA_NAME, a$ as SeedModels, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, Y as appState, a4 as arweaveL1FinalizeJobs, ao as client, aJ as createNewItem, bk as createSchema, an as eventEmitter, az as generateId, b4 as getAddressesForItemsFilter, ba as getArweaveUploadStatus, b5 as getArweaveUrlForTransaction, aV as getCanonicalItemPropertiesFromEas, aG as getClient, G as getCorrectId, U as getEasSchemaForItemProperty, aW as getEasSchemaUidBySchemaName, p as getGetAdditionalSyncAddresses, bg as getGetPublisherForNewSeeds, aU as getItemPropertiesFromEas, aT as getItemVersionsFromEas, aL as getMetadataLatest, aS as getModelSchemasFromEas, bi as getRevokeExecutor, bn as getSchemaNameFromId, aY as getSeedsBySchemaName, aX as getSeedsFromSchemaUids, b7 as getUploadApiArweaveDataUrl, b9 as getUploadApiArweaveStatusUrl, be as getUploadExecutor, b8 as getUploadPipelineTransactionStatus, aK as getVersionData, as as importJsonSchema, bb as isArweaveL1AnchoringComplete, bm as listSchemas, aM as loadAllSchemasFromDb, a8 as modelSchemas, a9 as modelUids, y as models, b6 as normalizeUploadApiBaseUrl, a_ as pickLatestPropertyAttestationsByRefAndSchema, z as properties, aN as propertyMachine, ad as propertyUids, ae as publishProcesses, bc as queryArweaveGatewayTransaction, au as readJsonImportFile, bl as readSchema, af as schemas, bj as setAdditionalSyncAddresses, bf as setGetPublisherForNewSeeds, bh as setRevokeExecutor, aR as setSchemaUidForModel, aQ as setSchemaUidForSchemaDefinition, bd as setUploadExecutor, av as syncSchemaFromSource, aw as transformImportToSchemaFile, b3 as updateSeedRevokedAt, ag as uploadProcesses, aA as waitForEntityIdle, aZ as withExcludeRevokedFilter } from './index-BvZCYMxA.js';
-export { getPropertySchema } from './property-BOdk-wW1.js';
+import { p as BaseDb, al as versions, aL as isPlaceholderUid, aa as metadata, E as isValidEasAttestationUid, aM as normalizeBytes32Hex, G as getLatestPublishedVersionRow, s as seeds, O as parseListPropertyValueFromStorage, t as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString, b as ModelPropertyDataTypes, v as BaseFileManager, x as htmlEmbeddedImageCoPublish, u as Item, aN as getArweaveUrlForTransaction, aF as waitForEntityIdle, w as getContentHash } from './index-BrD_NNaX.js';
+export { aO as ADDRESSES_PERSISTED_EVENT, y as BaseArweaveClient, aR as ClientManagerState, bf as DEFAULT_ARWEAVE_GATEWAYS, bg as DEFAULT_ARWEAVE_GRAPHQL_URL, be as DEFAULT_ARWEAVE_HOST, a5 as EasClient, W as INTERNAL_DATA_TYPES, aZ as ImageSize, ar as ItemProperty, aS as MachineIds, M as Model, aY as SEED_PROTOCOL_SCHEMA_NAME, bd as SeedModels, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, a1 as appState, a8 as arweaveL1FinalizeJobs, b8 as classifyMediaRef, at as client, aT as createNewItem, bx as createSchema, as as eventEmitter, aE as generateId, bi as getAddressesForItemsFilter, bn as getArweaveUploadStatus, b3 as getCanonicalItemPropertiesFromEas, aQ as getClient, Q as getCorrectId, _ as getEasSchemaForItemProperty, b4 as getEasSchemaUidBySchemaName, bb as getFeedItemStringField, q as getGetAdditionalSyncAddresses, bt as getGetPublisherForNewSeeds, b2 as getItemPropertiesFromEas, b1 as getItemVersionsFromEas, aV as getMetadataLatest, b0 as getModelSchemasFromEas, bv as getRevokeExecutor, bA as getSchemaNameFromId, b6 as getSeedsBySchemaName, b5 as getSeedsFromSchemaUids, bk as getUploadApiArweaveDataUrl, bm as getUploadApiArweaveStatusUrl, br as getUploadExecutor, bl as getUploadPipelineTransactionStatus, aU as getVersionData, ax as importJsonSchema, bo as isArweaveL1AnchoringComplete, bz as listSchemas, aW as loadAllSchemasFromDb, ac as modelSchemas, ad as modelUids, A as models, ba as normalizeFeedItemFields, bj as normalizeUploadApiBaseUrl, aP as parseAddressesPersistedPayload, bc as pickLatestPropertyAttestationsByRefAndSchema, C as properties, aX as propertyMachine, ah as propertyUids, ai as publishProcesses, bp as queryArweaveGatewayTransaction, az as readJsonImportFile, by as readSchema, b9 as resolveMediaRef, aj as schemas, bw as setAdditionalSyncAddresses, bs as setGetPublisherForNewSeeds, bu as setRevokeExecutor, a$ as setSchemaUidForModel, a_ as setSchemaUidForSchemaDefinition, bq as setUploadExecutor, aA as syncSchemaFromSource, aB as transformImportToSchemaFile, bh as updateSeedRevokedAt, ak as uploadProcesses, b7 as withExcludeRevokedFilter } from './index-BrD_NNaX.js';
+export { getPropertySchema } from './property-C63Ddzap.js';
 import { eq, desc, or, and, isNotNull, ne } from 'drizzle-orm';
-export { S as Schema, a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-BQ5W3aOW.js';
-export { ModelProperty } from './ModelProperty-ChevZoUy.js';
-export { isItemOwned } from './ownership-tVhYQomL.js';
-import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-B74LN_bz.js';
-export { PublishValidationFailedError, resolvePublishPayloadValues, validateItemForPublish } from './getPublishPayload-eJL7ktes.js';
-export { itemHasPublishUploadCandidates } from './getPublishUploads-CKm5dsL6.js';
+export { S as Schema, a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-CqqcEexA.js';
+export { ModelProperty } from './ModelProperty-DWtv9fQr.js';
+export { isItemOwned } from './ownership-BK6suksO.js';
+import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-Bz5B4DSA.js';
+export { PublishValidationFailedError, resolvePublishPayloadValues, validateItemForPublish } from './getPublishPayload-DpYwi-rd.js';
+export { itemHasPublishUploadCandidates } from './getPublishUploads-DS2dQ4Ho.js';
+import { parseFragment, serialize } from 'parse5';
+import 'pluralize';
 import 'js-yaml';
 import 'fs';
 import 'xstate';
@@ -17,7 +19,6 @@ import 'nanoid';
 import 'nanoid-dictionary';
 import 'debug';
 import 'ethers';
-import 'pluralize';
 import '@sinclair/typebox';
 import 'drizzle-orm/casing';
 import 'lodash-es';
@@ -25,16 +26,15 @@ import 'rxjs';
 import 'eventemitter3';
 import 'arweave';
 import 'js-sha3';
-import './SchemaValidationService-DQx83Cte.js';
+import './SchemaValidationService-Cb-b4kpD.js';
 import '@sinclair/typebox/value';
 
-const isEmptyUid = (uid) => uid == null || uid === '' || uid === 'NULL';
 /**
  * Updates the version record with the attestation UID after a Version attestation is created.
  * Targets the version without a uid yet (the one being published).
  * Publisher is immutable once set: we never overwrite an existing publisher.
  */
-const updateVersionUid = async ({ seedLocalId, versionUid, publisher, }) => {
+const updateVersionUid = async ({ seedLocalId, versionUid, publisher, attestationCreatedAt, }) => {
     if (!seedLocalId || !versionUid) {
         return;
     }
@@ -46,7 +46,7 @@ const updateVersionUid = async ({ seedLocalId, versionUid, publisher, }) => {
         .from(versions)
         .where(eq(versions.seedLocalId, seedLocalId))
         .orderBy(desc(versions.createdAt));
-    const toUpdate = rows.find((r) => r.localId && isEmptyUid(r.uid));
+    const toUpdate = rows.find((r) => r.localId && isPlaceholderUid(r.uid));
     if (!toUpdate?.localId)
         return;
     let shouldSetPublisher = publisher != null && publisher !== '';
@@ -58,11 +58,78 @@ const updateVersionUid = async ({ seedLocalId, versionUid, publisher, }) => {
         .set({
         uid: versionUid,
         ...(shouldSetPublisher && { publisher }),
+        ...(attestationCreatedAt != null && { attestationCreatedAt }),
         updatedAt: Date.now(),
     })
         .where(eq(versions.localId, toUpdate.localId));
 };
 
+/**
+ * After property attestations succeed, write EAS UIDs onto the latest placeholder metadata row
+ * per schema (and optional property name) so getPublishPendingDiff stays aligned with on-chain state.
+ */
+async function applyPropertyAttestationUidsFromPublish(params) {
+    const { seedLocalId, attestationCreatedAtMs, pairs, versionUid } = params;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !seedLocalId || pairs.length === 0)
+        return;
+    const rows = await appDb.select().from(metadata).where(eq(metadata.seedLocalId, seedLocalId));
+    if (rows.length === 0)
+        return;
+    const working = rows.map((r) => ({ ...r }));
+    const validVersion = versionUid != null && versionUid !== '' && isValidEasAttestationUid(versionUid)
+        ? versionUid
+        : undefined;
+    for (const pair of pairs) {
+        const att = pair.attestationUid?.trim();
+        if (!isValidEasAttestationUid(att))
+            continue;
+        const wantSchema = normalizeBytes32Hex(pair.schemaUid);
+        if (!wantSchema)
+            continue;
+        const candidates = working
+            .filter((r) => {
+            if (!r.schemaUid)
+                return false;
+            if (normalizeBytes32Hex(r.schemaUid) !== wantSchema)
+                return false;
+            if (pair.propertyName != null && pair.propertyName !== '') {
+                if (r.propertyName !== pair.propertyName)
+                    return false;
+            }
+            return true;
+        })
+            .sort((a, b) => {
+            const ta = a.attestationCreatedAt ?? a.createdAt ?? 0;
+            const tb = b.attestationCreatedAt ?? b.createdAt ?? 0;
+            if (tb !== ta)
+                return tb - ta;
+            return String(b.localId ?? '').localeCompare(String(a.localId ?? ''));
+        });
+        const target = candidates.find((r) => isPlaceholderUid(r.uid));
+        if (!target?.localId)
+            continue;
+        await appDb
+            .update(metadata)
+            .set({
+            uid: att,
+            ...(attestationCreatedAtMs != null && { attestationCreatedAt: attestationCreatedAtMs }),
+            ...(validVersion && { versionUid: validVersion }),
+            updatedAt: Date.now(),
+        })
+            .where(eq(metadata.localId, target.localId));
+        const i = working.findIndex((r) => r.localId === target.localId);
+        if (i >= 0) {
+            working[i] = {
+                ...working[i],
+                uid: att,
+                attestationCreatedAt: attestationCreatedAtMs ?? working[i].attestationCreatedAt,
+                ...(validVersion && { versionUid: validVersion }),
+            };
+        }
+    }
+}
+
 const getVersionsForSeedUid = async (seedUid) => {
     if (!seedUid)
         return [];
@@ -76,7 +143,7 @@ const getVersionsForSeedUid = async (seedUid) => {
         .map((r) => ({ uid: r.uid }));
 };
 
-function resolveSeedIds(arg) {
+function resolveSeedIds$1(arg) {
     if (arg && typeof arg === 'object' && 'seedLocalId' in arg) {
         const item = arg;
         return {
@@ -87,12 +154,12 @@ function resolveSeedIds(arg) {
     return arg;
 }
 /**
- * Lists properties with unpublished local edits (latest metadata row has no `uid`).
- * Compares to the previous row with a `uid` for the same `property_name` when present.
- * Use for pre-publish summaries and “what changed” UI.
+ * Per property: the **latest** metadata row (by `attestationCreatedAt` / `createdAt`) lacks a valid
+ * EAS attestation `uid` — local edit or missing post-publish UID backfill. **Not** equivalent to
+ * draft vs onchain for the whole seed; use `getSeedPublishState` for that.
  */
 async function getPublishPendingDiff(arg) {
-    const { seedLocalId, seedUid } = resolveSeedIds(arg);
+    const { seedLocalId, seedUid } = resolveSeedIds$1(arg);
     const appDb = BaseDb.getAppDb();
     const empty = {
         pendingProperties: [],
@@ -125,9 +192,9 @@ async function getPublishPendingDiff(arg) {
         const latest = list[0];
         if (!latest)
             continue;
-        const hasUid = !!latest.uid && String(latest.uid).trim() !== '';
+        const hasUid = isValidEasAttestationUid(latest.uid);
         if (!hasUid) {
-            const prevWithUid = list.find((r) => r.uid && String(r.uid).trim() !== '');
+            const prevWithUid = list.find((r) => isValidEasAttestationUid(r.uid));
             pendingProperties.push({
                 propertyName,
                 currentValue: latest.propertyValue ?? null,
@@ -140,21 +207,12 @@ async function getPublishPendingDiff(arg) {
     let lastPublishedVersionUid = null;
     let lastVersionPublishedAt = null;
     if (seedLocalId) {
-        const vRows = await appDb
-            .select({
-            uid: versions.uid,
-            attestationCreatedAt: versions.attestationCreatedAt,
-        })
-            .from(versions)
-            .where(eq(versions.seedLocalId, seedLocalId))
-            .orderBy(desc(versions.createdAt))
-            .limit(1);
-        const vr = vRows[0];
-        if (vr?.uid && String(vr.uid).trim() !== '') {
-            lastPublishedVersionUid = vr.uid;
-        }
-        if (vr?.attestationCreatedAt != null) {
-            lastVersionPublishedAt = vr.attestationCreatedAt;
+        const published = await getLatestPublishedVersionRow(seedLocalId);
+        if (published) {
+            lastPublishedVersionUid = published.uid;
+            if (published.attestationCreatedAt != null) {
+                lastVersionPublishedAt = published.attestationCreatedAt;
+            }
         }
     }
     return {
@@ -164,6 +222,87 @@ async function getPublishPendingDiff(arg) {
     };
 }
 
+function resolveSeedIds(arg) {
+    if (arg && typeof arg === 'object' && 'seedLocalId' in arg) {
+        const item = arg;
+        return {
+            seedLocalId: item.seedLocalId,
+            seedUid: item.seedUid,
+        };
+    }
+    return arg;
+}
+function maxMs(a, b) {
+    const x = a ?? null;
+    const y = b ?? null;
+    if (x == null)
+        return y;
+    if (y == null)
+        return x;
+    return Math.max(x, y);
+}
+/**
+ * Whether the seed has **any** on-chain anchor in local SQLite: valid EAS UID on the seed row,
+ * on the newest **published** version row (`getLatestPublishedVersionRow`), or on **any** metadata row.
+ * Not the same as “no unpublished edits”; see `getPublishPendingDiff` for per-property head rows.
+ */
+async function getSeedPublishState(arg) {
+    const { seedLocalId, seedUid } = resolveSeedIds(arg);
+    const appDb = BaseDb.getAppDb();
+    const empty = {
+        status: 'draft',
+        seedAttestationUid: null,
+        versionAttestationUid: null,
+        explorerUid: null,
+        lastAttestedAtMs: null,
+    };
+    if (!appDb || (!seedLocalId && !seedUid)) {
+        return empty;
+    }
+    const seedWhere = seedLocalId && seedUid
+        ? or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid))
+        : seedLocalId
+            ? eq(seeds.localId, seedLocalId)
+            : eq(seeds.uid, seedUid);
+    const seedRows = await appDb.select().from(seeds).where(seedWhere).limit(1);
+    const seedRow = seedRows[0];
+    const seedAttestationUid = seedRow?.uid && isValidEasAttestationUid(seedRow.uid) ? seedRow.uid : null;
+    let lastAttestedAtMs = seedRow?.attestationCreatedAt ?? null;
+    const resolvedSeedLocalId = seedRow?.localId ?? seedLocalId;
+    let versionAttestationUid = null;
+    if (resolvedSeedLocalId) {
+        const v = await getLatestPublishedVersionRow(resolvedSeedLocalId);
+        if (v?.uid) {
+            versionAttestationUid = v.uid;
+            lastAttestedAtMs = maxMs(lastAttestedAtMs, v.attestationCreatedAt ?? undefined);
+        }
+    }
+    const metaWhere = seedLocalId && seedUid
+        ? or(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid))
+        : seedLocalId
+            ? eq(metadata.seedLocalId, seedLocalId)
+            : eq(metadata.seedUid, seedUid);
+    const metaRows = await appDb.select().from(metadata).where(metaWhere);
+    let metadataExplorerUid = null;
+    for (const row of metaRows) {
+        if (!isValidEasAttestationUid(row.uid))
+            continue;
+        if (!metadataExplorerUid)
+            metadataExplorerUid = row.uid;
+        const t = row.attestationCreatedAt ?? row.createdAt;
+        lastAttestedAtMs = maxMs(lastAttestedAtMs, t ?? undefined);
+    }
+    const hasOnchain = !!(seedAttestationUid || versionAttestationUid || metadataExplorerUid);
+    const explorerUid = seedAttestationUid ?? versionAttestationUid ?? metadataExplorerUid;
+    return {
+        status: hasOnchain ? 'onchain' : 'draft',
+        seedAttestationUid,
+        versionAttestationUid,
+        explorerUid,
+        lastAttestedAtMs,
+    };
+}
+
 /**
  * Returns attestation UIDs (metadata.uid) for all metadata records belonging to a seed.
  * Used when revoking attestations - metadata attestations must be revoked.
@@ -175,7 +314,7 @@ const getMetadataAttestationUidsForSeedUid = async (seedUid) => {
     const rows = await appDb
         .select({ uid: metadata.uid, schemaUid: metadata.schemaUid })
         .from(metadata)
-        .where(and(eq(metadata.seedUid, seedUid), isNotNull(metadata.uid), ne(metadata.uid, ''), ne(metadata.uid, '0x' + '0'.repeat(64))));
+        .where(and(eq(metadata.seedUid, seedUid), isNotNull(metadata.uid), ne(metadata.uid, ''), ne(metadata.uid, 'NULL'), ne(metadata.uid, '0x' + '0'.repeat(64))));
     return rows
         .filter((r) => r.uid != null && r.schemaUid != null)
         .map((r) => ({ uid: r.uid, schemaUid: r.schemaUid }));
@@ -282,7 +421,7 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
     visited.add(seedLocalId);
     const result = [];
     const { itemRelationProperties, itemImageProperties, itemListProperties } = await getSegmentedItemProperties(item);
-    const getItemMod = await import('./getItem-Bd9U9Yih.js');
+    const getItemMod = await import('./getItem-VI3QqdZH.js');
     const { getItem } = getItemMod;
     const processRelationOrImage = async (prop) => {
         const snapshot = prop.getService().getSnapshot();
@@ -303,8 +442,8 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
         if (!value && prop.propertyName && isStorageSeed) {
             const ctx = context;
             if (ctx.seedLocalId || ctx.seedUid) {
-                const _mod_0 = await import('./index-BvZCYMxA.js');
-                const _ns_0 = _mod_0.bC;
+                const _mod_0 = await import('./index-BrD_NNaX.js');
+                const _ns_0 = _mod_0.bP;
                 const { getPropertyData } = _ns_0;
                 const meta = await getPropertyData({
                     propertyName: prop.propertyName,
@@ -362,5 +501,353 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
     return result;
 }
 
-export { BaseDb, applyArweaveL1TransactionIdLocal, getAttesterForSeed, getMetadataAttestationUidsForSeedUid, getPublishPendingDiff, getRelatedItemsForPublish, getSegmentedItemProperties, getVersionsForSeedUid, metadata, seeds, updateVersionUid, versions };
+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;
+}
+function setAttr(node, name, value) {
+    if (!node.attrs)
+        node.attrs = [];
+    const i = node.attrs.findIndex((x) => x.name === name);
+    if (i >= 0)
+        node.attrs[i].value = value;
+    else
+        node.attrs.push({ name, 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 });
+                    }
+                }
+            }
+        }
+        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;
+}
+/**
+ * Replace `data:image/...` src values with Arweave URLs using upload results keyed by image seed local id.
+ */
+function replaceDataUrisInParsedHtml(html, replacements) {
+    if (replacements.size === 0)
+        return html;
+    const fragment = parseFragment(html);
+    const walk = (node) => {
+        if (node.nodeName === '#text' || node.nodeName === '#comment')
+            return;
+        const el = node;
+        if (el.tagName === 'img') {
+            const src = getAttr(el, 'src')?.trim();
+            if (src && replacements.has(src)) {
+                setAttr(el, 'src', replacements.get(src));
+            }
+        }
+        const parent = el;
+        if (parent.childNodes) {
+            for (const c of parent.childNodes)
+                walk(c);
+        }
+    };
+    for (const c of fragment.childNodes)
+        walk(c);
+    return serialize(fragment);
+}
+async function deleteCoPublishRowsForParent(appDb, parentSeedLocalId) {
+    if (!appDb)
+        return;
+    await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId));
+}
+/**
+ * Create an Image item and persist a data URI into its storageTransactionId (same path as user paste).
+ */
+async function createImageItemFromDataUri(dataUri) {
+    const imageItem = await Item.create({
+        modelName: 'Image',
+    });
+    await waitForEntityIdle(imageItem, { timeout: 60000 });
+    // #region agent log
+    fetch('http://127.0.0.1:7754/ingest/2810478a-7cf0-49a8-bc23-760b81417972', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'X-Debug-Session-Id': '5954ea' },
+        body: JSON.stringify({
+            sessionId: '5954ea',
+            location: 'htmlEmbeddedDataUriPublish.ts:createImageItemFromDataUri',
+            message: 'after waitForEntityIdle',
+            data: {
+                seedLocalId: imageItem.seedLocalId,
+                allPropertyKeys: Object.keys(imageItem.allProperties),
+                hasStorageTransactionId: !!imageItem.allProperties['storageTransactionId'],
+                hasStorageTransactionWrongKey: !!imageItem.allProperties['storageTransaction'],
+            },
+            timestamp: Date.now(),
+            runId: 'post-fix',
+            hypothesisId: 'A',
+        }),
+    }).catch(() => { });
+    // #endregion
+    const st = imageItem.internalProperties['storageTransactionId'] ??
+        imageItem.allProperties['storageTransactionId'];
+    if (!st) {
+        throw new Error('Image item missing storageTransactionId property');
+    }
+    st.value = dataUri;
+    await st.save();
+    await waitForEntityIdle(imageItem, { timeout: 60000 });
+    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: [] };
+    }
+    await deleteCoPublishRowsForParent(appDb, item.seedLocalId);
+    const deferred = new Set();
+    for (const p of item.properties) {
+        const def = p.propertyDef;
+        if (!def || normalizeDataTypeLocal(def.dataType) !== ModelPropertyDataTypes.Html)
+            continue;
+        const policy = resolveEffectiveHtmlEmbeddedDataUriPolicy(def, publishPolicy);
+        if (policy !== 'materialize')
+            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));
+            }
+        }
+        let extracted;
+        try {
+            extracted = await extractDataUriImagesFromHtml(html);
+        }
+        catch (e) {
+            if (e instanceof HtmlEmbeddedDataUriLimitError)
+                throw e;
+            throw e;
+        }
+        if (extracted.length === 0)
+            continue;
+        deferred.add(htmlSeedLocalId.trim());
+        for (const ent of extracted) {
+            const { seedLocalId: imageSeedLocalId } = await createImageItemFromDataUri(ent.dataUri);
+            const now = Date.now();
+            await appDb.insert(htmlEmbeddedImageCoPublish).values({
+                parentSeedLocalId: item.seedLocalId,
+                htmlSeedLocalId: htmlSeedLocalId.trim(),
+                imageSeedLocalId,
+                stableKey: ent.stableKey,
+                createdAt: now,
+            }).onConflictDoNothing();
+        }
+    }
+    return { deferredHtmlSeedLocalIds: [...deferred] };
+}
+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.
+ */
+async function rewriteHtmlEmbeddedImagesOnDisk(parentSeedLocalId, uploadedTransactions) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const rows = await appDb
+        .select()
+        .from(htmlEmbeddedImageCoPublish)
+        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId));
+    if (rows.length === 0)
+        return;
+    const txByImageSeed = new Map();
+    for (const u of uploadedTransactions) {
+        if (u.seedLocalId && u.txId) {
+            txByImageSeed.set(u.seedLocalId.trim(), u.txId.trim());
+        }
+    }
+    const htmlSeedIds = new Set(rows.map((r) => String(r.htmlSeedLocalId).trim()));
+    const parentItem = await Item.find({ seedLocalId: parentSeedLocalId });
+    const refByHtmlSeed = new Map();
+    if (parentItem) {
+        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 pv = typeof ctx?.propertyValue === 'string' ? ctx.propertyValue.trim() : '';
+            const refResolved = ctx?.refResolvedValue;
+            if (pv && refResolved)
+                refByHtmlSeed.set(pv, refResolved);
+        }
+    }
+    for (const htmlSeedLocalId of htmlSeedIds) {
+        const refResolved = refByHtmlSeed.get(String(htmlSeedLocalId));
+        if (!refResolved)
+            continue;
+        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 rows) {
+            if (String(r.htmlSeedLocalId).trim() !== htmlSeedLocalId)
+                continue;
+            const txId = txByImageSeed.get(r.imageSeedLocalId.trim());
+            if (!txId)
+                continue;
+            const dataUri = await findDataUriForStableKey(html, r.stableKey);
+            if (dataUri)
+                replacements.set(dataUri, getArweaveUrlForTransaction(txId));
+        }
+        if (replacements.size === 0)
+            continue;
+        const newHtml = replaceDataUrisInParsedHtml(html, replacements);
+        try {
+            await BaseFileManager.saveFile(filePath, newHtml);
+        }
+        catch {
+            const fs = await BaseFileManager.getFs();
+            fs.writeFileSync(filePath, newHtml);
+        }
+        if (parentItem) {
+            for (const p of parentItem.properties) {
+                const snap = p.getService().getSnapshot();
+                const ctx = 'context' in snap ? snap.context : null;
+                const pv = typeof ctx?.propertyValue === 'string' ? ctx.propertyValue.trim() : '';
+                if (pv === htmlSeedLocalId) {
+                    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()));
+}
+
+export { BaseDb, BaseFileManager, BaseFileManager as FileManager, HTML_EMBEDDED_MAX_IMAGES_PER_DOC, HTML_EMBEDDED_MAX_IMAGE_BYTES, HTML_EMBEDDED_MAX_TOTAL_BYTES, HtmlEmbeddedDataUriLimitError, Item, ModelPropertyDataTypes, applyArweaveL1TransactionIdLocal, applyPropertyAttestationUidsFromPublish, clearHtmlEmbeddedImageCoPublishRows, extractDataUriImagesFromHtml, getArweaveUrlForTransaction, getAttesterForSeed, getMetadataAttestationUidsForSeedUid, getPublishPendingDiff, getRelatedItemsForPublish, getSeedPublishState, getSegmentedItemProperties, getVersionsForSeedUid, htmlEmbeddedImageCoPublish, isPlaceholderUid, isValidEasAttestationUid, metadata, normalizeBytes32Hex, prepareHtmlEmbeddedImagesForPublish, replaceDataUrisInParsedHtml, resolveEffectiveHtmlEmbeddedDataUriPolicy, rewriteHtmlEmbeddedImagesOnDisk, seeds, updateVersionUid, versions, waitForEntityIdle };
 //# sourceMappingURL=main.js.map