@seedprotocol/sdk 0.6.10 → 0.7.1

package/dist/main.js

@@ -1,50 +1,55 @@
 import 'reflect-metadata';
-export { M as Model } from './index-HRHkbVQd.js';
-import { o as normalizePublisher, k as isDataType, M as ModelPropertyDataTypes, n as normalizeDataType } from './db-WbrzEf7c.js';
-export { v as getAddressesForItemsFilter, w as normalizeAddressConfig, x as normalizeAddressList, r as normalizeHexAddress } from './db-WbrzEf7c.js';
-export { getPropertySchema } from './property-CQjuZ4JW.js';
-import { n as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString, b as getArweaveUrlForTransaction } from './index-280bL-n4.js';
-export { c as classifyMediaRef, d as closestImageSize, f as ensureImageLocal, e as eventEmitter, g as getCorrectId, h as getFeedItemStringField, i as isPublishedSeedRef, j as normalizeArweaveTxIdForEnsure, k as normalizeFeedItemFields, l as resolveMediaRef } from './index-280bL-n4.js';
-import { x as compareMetadataRowsLatestFirst, c as getLatestPublishedVersionRow, p as parseListPropertyValueFromStorage, I as Item, g as getContentHash, n as waitForEntityIdle } from './ClientManager-ChcmUL47.js';
-export { A as ADDRESSES_PERSISTED_EVENT, y as ClientManagerState, E as EAS_CHAIN_ID_APP_STATE_KEY, f as ItemProperty, h as ItemPropertySaveValidationError, L as LOCAL_COPIES_REMOVED_EVENT, M as MachineIds, d as assertLocalDbChain, z as claimUnpublishedDrafts, C as client, B as createLocalQueryDataSource, D as createNewItem, F as createSchema, G as easSyncActor, H as getClient, J as getEasSchemaForItemProperty, e as getGetAdditionalSyncAddresses, K as getGetPublisherForNewSeeds, N as getMetadataLatest, O as getPublishedSeedRecord, P as getRevokeExecutor, Q as getSchemaNameFromId, R as getUploadExecutor, S as getVersionData, j as importJsonSchema, T as isItemOwned, U as isLocalUnsealedDraft, V as isSeedQueryLocalSourceRegistered, W as isSeedRowOwned, l as listRelationEasPropertyName, X as listSchemas, Y as loadAllSchemasFromDb, Z as mergeEasSyncRequestIntents, _ as ownedPublisherSql, $ as parseAddressesPersistedPayload, a0 as propertyMachine, a1 as publisherInAddressListSql, a2 as publisherIsInOwnedSet, m as readJsonImportFile, a3 as readSchema, a4 as registerSeedQueryLocalSource, a5 as requestEasSyncFromAddressChange, a6 as requestEasSyncFromEventBus, a7 as requestEasSyncFromModelsInit, a8 as sendEasSyncClientRequest, a9 as setAdditionalSyncAddresses, aa as setGetPublisherForNewSeeds, ab as setRevokeExecutor, ac as setUploadExecutor, ad as startEasSyncActor, s as syncSchemaFromSource, t as transformImportToSchemaFile, ae as unregisterSeedQueryLocalSource } from './ClientManager-ChcmUL47.js';
-import { a as BaseDb, v as versions, b as metadata, r as seeds, I as INTERNAL_PROPERTY_NAMES, Z as ZERO_BYTES32, B as BaseFileManager, h as htmlEmbeddedImageCoPublish } from './BasePathResolver-B6CKqoKw.js';
-export { E as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, x as INTERNAL_DATA_TYPES, C as ImageSize, D as SEED_PROTOCOL_SCHEMA_NAME, F as SeedModels, G as VERSION_SCHEMA_DEF, V as VERSION_SCHEMA_UID, H as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, c as appState, d as arweaveL1FinalizeJobs, f as easSyncProcesses, i as modelSchemas, j as modelUids, m as models, p as properties, o as propertyUids, q as publishProcesses, s as schemas, u as uploadProcesses } from './BasePathResolver-B6CKqoKw.js';
-import { eq, desc, or, and, isNotNull, ne } from 'drizzle-orm';
+export { M as Model } from './index-Y-yYyRBf.js';
+import { s as normalizePublisher, k as isDataType, M as ModelPropertyDataTypes, n as normalizeDataType } from './db-Lw0KVZmc.js';
+export { A as AmbiguousModelError, m as eventEmitter, z as getAddressesForItemsFilter, C as normalizeAddressConfig, E as normalizeAddressList, u as normalizeHexAddress } from './db-Lw0KVZmc.js';
+export { getPropertySchema } from './property-ByaiSyUK.js';
+import { n as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString, b as getArweaveUrlForTransaction } from './tabEvents-C6NXS6Jl.js';
+export { A as ADDRESSES_PERSISTED_EVENT, F as FILES_CHANGED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT, T as TabLockTimeoutError, c as classifyMediaRef, d as closestImageSize, f as ensureImageLocal, g as getCorrectId, h as getFeedItemStringField, j as isLeaderTab, i as isPublishedSeedRef, k as normalizeArweaveTxIdForEnsure, l as normalizeFeedItemFields, p as parseAddressesPersistedPayload, m as resolveMediaRef, w as whenLeaderTab } from './tabEvents-C6NXS6Jl.js';
+import { g as getContentHash } from './ClientManager-DngaZdw6.js';
+export { E as EAS_CHAIN_ID_APP_STATE_KEY, a as assertLocalDbChain, c as claimUnpublishedDrafts, C as client, d as createLocalQueryDataSource, e as createSchema, f as easSyncActor, h as getClient, j as getPublishedSeedRecord, k as getSchemaNameFromId, i as importJsonSchema, m as isSeedQueryLocalSourceRegistered, n as listSchemas, o as loadAllSchemasFromDb, p as mergeEasSyncRequestIntents, r as readJsonImportFile, q as readSchema, u as registerSeedQueryLocalSource, v as requestEasSyncFromAddressChange, x as requestEasSyncFromEventBus, y as requestEasSyncFromModelsInit, z as sendEasSyncClientRequest, A as startEasSyncActor, s as syncSchemaFromSource, t as transformImportToSchemaFile, B as unregisterSeedQueryLocalSource } from './ClientManager-DngaZdw6.js';
+import { i as isVersionRevoked, q as compareMetadataRowsLatestFirst, t as isPublishedMetadataRow, b as getLatestPublishedVersionRow, p as parseListPropertyValueFromStorage, I as Item, j as waitForEntityIdle } from './Item-ZUAmf943.js';
+export { C as ClientManagerState, f as ItemProperty, h as ItemPropertySaveValidationError, M as METADATA_LATEST_FIRST_ORDER_SQL, u as MachineIds, x as createNewItem, y as getEasSchemaForItemProperty, e as getGetAdditionalSyncAddresses, z as getGetPublisherForNewSeeds, A as getMetadataLatest, B as getRevokeExecutor, D as getUploadExecutor, E as getVersionData, F as isItemOwned, G as isLocalUnsealedDraft, H as isSeedRowOwned, l as listRelationEasPropertyName, J as ownedPublisherSql, K as pickLatestMetadataRowPerProperty, L as propertyMachine, N as publisherInAddressListSql, O as publisherIsInOwnedSet, P as setAdditionalSyncAddresses, Q as setGetPublisherForNewSeeds, R as setRevokeExecutor, S as setUploadExecutor } from './Item-ZUAmf943.js';
+import { B as BaseDb, v as versions, r as seeds, m as metadata, h as htmlEmbeddedImageCoPublish, a as BaseFileManager, C as INTERNAL_STORAGE_MODEL_FILE_IDS, I as INTERNAL_PROPERTY_NAMES, Z as ZERO_BYTES32 } from './BasePathResolver-DRT09oVv.js';
+export { E as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, x as INTERNAL_DATA_TYPES, D as ImageSize, F as SEED_PROTOCOL_SCHEMA_NAME, G as SeedModels, H as VERSION_SCHEMA_DEF, V as VERSION_SCHEMA_UID, J as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, b as appState, c as arweaveL1FinalizeJobs, e as easSyncProcesses, g as modelSchemas, i as modelUids, j as models, p as properties, o as propertyUids, q as publishProcesses, s as schemas, u as uploadProcesses } from './BasePathResolver-DRT09oVv.js';
+import { eq, desc, and, or, isNotNull, ne } from 'drizzle-orm';
 import { isPlaceholderUid, isValidEasAttestationUid, normalizeBytes32Hex } from '@seedprotocol/eas';
 export { EAS_CHAIN_DEPLOYMENTS, BaseEasClient as EasClient, getCanonicalItemPropertiesFromEas, getEasChainDeployment, getEasEndpoint, getEasReadChainId, getEasSchemaUidBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getSeedsBySchemaName, getSeedsFromSchemaUids, isPlaceholderUid, isValidEasAttestationUid, normalizeBytes32Hex, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForModel, setSchemaUidForSchemaDefinition, withExcludeRevokedFilter } from '@seedprotocol/eas';
-export { S as Schema, d as deleteModelFromSchema, a as deletePropertyFromModel, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-a8uO-hIZ.js';
-export { ModelProperty } from './ModelProperty-D79uV42p.js';
-export { getModelSchemasFromEas } from './eas-CfYCu4IX.js';
+import { generateId } from './generateId-BopUwD8F.js';
+export { S as Schema, d as deleteModelFromSchema, a as deletePropertyFromModel, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-D-Ud-XYw.js';
+export { F as FileSystemLockedError } from './errors-CrBxGWah.js';
+export { M as MODEL_AMBIGUOUS_EVENT } from './resolveModelForSyncedSeed-B0tco3zG.js';
+export { ModelProperty } from './ModelProperty-6llK4MTH.js';
+export { getModelSchemasFromEas } from './eas-CQ-Smzk2.js';
 export { BaseArweaveClient, DEFAULT_ARWEAVE_GATEWAYS, DEFAULT_ARWEAVE_GRAPHQL_URL, DEFAULT_ARWEAVE_HOST, DEFAULT_GATEWAY_SIDECAR_HOST, DEFAULT_GATEWAY_SIDECAR_PORT, DEFAULT_SEED_FEED_HYPER_KEY, DEFAULT_SEED_GATEWAY_HYPER_KEY, SEED_RSS_IMAGE_RELATION_FIELD_KEYS, ensureReadGatewaySelected, fetchArweaveRawFromBaseUrl, fetchArweaveRawTextAcrossGateways, getArweaveReadBaseUrls, getArweaveUploadStatus, getDefaultArweaveReadGatewayHostsOrdered, getLastHealthyReadGatewayHost, getPreferredArweaveReadBaseUrls, getReadGatewayHostsForConfig, getResolvedArweaveReadBaseUrls, getResolvedSeedGatewayEndpoints, getUploadApiArweaveDataUrl, getUploadApiArweaveStatusUrl, getUploadPipelineTransactionStatus, invalidateReadGatewayCache, invalidateSidecarProbeCache, isArweaveL1AnchoringComplete, isEasAttestationExplorerUrl, isGatewayHostCircuitOpen, isKnownArweaveGatewayHostname, isReadGatewayKnownHealthy, mergePrimaryHostWithDefaults, normalizeGatewayHostKey, normalizeUploadApiBaseUrl, queryArweaveGatewayTransaction, queryArweaveGatewayTransactionWithFallback, recordGatewayHostFailure, recordGatewayHostSuccess, resetArweaveReadGatewayForTests, resolveSeedGatewayEndpoints, resolveSeedRssImageRelationFromItem, resolveSeedRssImageRelationRef, seedGatewayConfigFromClientContext, seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, setResolvedSeedGatewayEndpoints } from '@seedprotocol/arweave';
-export { u as updateSeedRevokedAt } from './updateSeedRevokedAt-CBcLfHWs.js';
-import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-BmKE71vU.js';
-export { PublishValidationFailedError, resolvePublishPayloadValues, validateItemForPublish } from './getPublishPayload-BIrTVUxb.js';
+export { u as updateSeedRevokedAt } from './updateSeedRevokedAt-CYwgVNlM.js';
+import { a as getSegmentedItemProperties, g as getPublishDraftGraph, i as isSeedRevoked, f as findRelatedSeedRow, b as isUnpublishedSeed, h as htmlPropertyNameForHtmlSeed, r as relatedModelNameFromDef } from './publishDraftGraph-BRm6Pq3Q.js';
+export { P as PublishValidationFailedError, R as RELATED_ITEM_UNPUBLISHED_CODE, a as RelatedItemUnpublishedError, r as resolvePublishPayloadValues, v as validateItemForPublish } from './getPublishPayload-76_KfB5Y.js';
 import 'pluralize';
-export { itemHasPublishUploadCandidates } from './getPublishUploads-C6cDeZdz.js';
-import { parseFragment, serialize } from 'parse5';
+export { itemHasPublishUploadCandidates } from './getPublishUploads-CqgMBD8f.js';
+import { parseFragment } from 'parse5';
 import 'js-yaml';
 import 'fs';
-export { generateId } from './generateId-BopUwD8F.js';
 import 'xstate';
 import 'debug';
 import './model-DGMe-TTm.js';
 import 'drizzle-orm/casing';
 import '@sinclair/typebox';
 import 'lodash-es';
+import 'rxjs';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@seedprotocol/query';
+import 'drizzle-orm/sqlite-core';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
-import 'rxjs';
-import 'drizzle-orm/sqlite-core';
-import './SchemaValidationService-Y49vqast.js';
+import './SchemaValidationService-IoS7JquP.js';
 import '@sinclair/typebox/value';
 import '@ethereum-attestation-service/eas-sdk';
 
 /**
  * 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).
+ * Targets the version without a uid yet (the one being published). A uid one of the seed's
+ * version rows already has is ignored.
  * Publisher is immutable once set: we never overwrite an existing publisher.
  */
 const updateVersionUid = async ({ seedLocalId, versionUid, publisher, attestationCreatedAt, }) => {
@@ -59,10 +64,37 @@ const updateVersionUid = async ({ seedLocalId, versionUid, publisher, attestatio
         .from(versions)
         .where(eq(versions.seedLocalId, seedLocalId))
         .orderBy(desc(versions.createdAt));
-    const toUpdate = rows.find((r) => r.localId && isPlaceholderUid(r.uid));
-    if (!toUpdate?.localId)
+    // Already recorded: nothing to stamp. A patch publish attaches to an existing version, and the
+    // modular executor's SeedPublished event still reports that version's uid; stamping it onto a
+    // local draft version would give two rows the same version uid.
+    const wanted = versionUid.toLowerCase();
+    if (rows.some((r) => r.uid?.toLowerCase() === wanted))
         return;
+    const toUpdate = rows.find((r) => r.localId && isPlaceholderUid(r.uid));
     const normalizedPublisher = normalizePublisher(publisher);
+    if (!toUpdate?.localId) {
+        // No local draft version took this attestation (e.g. a republish after unpublish, where every
+        // version row is a revoked attestation): record the new version so it is the latest one.
+        const [seed] = await appDb
+            .select({ type: seeds.type })
+            .from(seeds)
+            .where(eq(seeds.localId, seedLocalId))
+            .limit(1);
+        if (!seed)
+            return;
+        const now = Date.now();
+        await appDb.insert(versions).values({
+            localId: generateId(),
+            seedLocalId,
+            seedType: seed.type,
+            uid: versionUid,
+            createdAt: now,
+            updatedAt: now,
+            ...(normalizedPublisher && { publisher: normalizedPublisher }),
+            ...(attestationCreatedAt != null && { attestationCreatedAt }),
+        });
+        return;
+    }
     let shouldSetPublisher = normalizedPublisher != null;
     if (shouldSetPublisher && toUpdate.publisher != null && toUpdate.publisher !== '') {
         shouldSetPublisher = false;
@@ -83,6 +115,12 @@ const updateVersionUid = async ({ seedLocalId, versionUid, publisher, attestatio
  * so getPublishPendingDiff stays aligned with on-chain state.
  * When pair.propertyName is set, match that property even if the row has no schemaUid;
  * if the row has a schemaUid it must still match. Pair-only schema match remains for unnamed pairs.
+ *
+ * A full-snapshot publish (`new_version`, or a republish after unpublish) also attests properties
+ * whose rows are already attested (on an older version, or the revoked seed's). With no placeholder
+ * to take the uid, the attestation is recorded as a new row for the published version: a copy of
+ * the property's latest row with the new uid, so readers show the published version without a
+ * sync. Rows keep or get the published version's local id when `versionUid` has a version row.
  */
 async function applyPropertyAttestationUidsFromPublish(params) {
     const { seedLocalId, attestationCreatedAtMs, pairs, versionUid } = params;
@@ -96,6 +134,27 @@ async function applyPropertyAttestationUidsFromPublish(params) {
     const validVersion = versionUid != null && versionUid !== '' && isValidEasAttestationUid(versionUid)
         ? versionUid
         : undefined;
+    let versionLocalId;
+    let liveSeedUid = null;
+    if (validVersion) {
+        const [versionRow] = await appDb
+            .select({ localId: versions.localId, seedUid: versions.seedUid })
+            .from(versions)
+            .where(and(eq(versions.seedLocalId, seedLocalId), eq(versions.uid, validVersion)))
+            .limit(1);
+        versionLocalId = versionRow?.localId ?? undefined;
+        const [seedRow] = await appDb
+            .select({ uid: seeds.uid, revokedAt: seeds.revokedAt })
+            .from(seeds)
+            .where(eq(seeds.localId, seedLocalId))
+            .limit(1);
+        // A republish records its new seed uid after this; updateSeedUid fills it in then.
+        liveSeedUid =
+            versionRow?.seedUid ??
+                (isValidEasAttestationUid(seedRow?.uid) && !isVersionRevoked(seedRow?.revokedAt)
+                    ? seedRow.uid
+                    : null);
+    }
     for (const pair of pairs) {
         const att = pair.attestationUid?.trim();
         if (!isValidEasAttestationUid(att))
@@ -106,6 +165,9 @@ async function applyPropertyAttestationUidsFromPublish(params) {
         const pairName = pair.propertyName != null && pair.propertyName !== '' ? pair.propertyName : undefined;
         const candidates = working
             .filter((r) => {
+            // Rows sync derived for ItemStorage properties aren't placeholders for an attestation.
+            if (r.derivedFromUid != null)
+                return false;
             if (pairName) {
                 if (r.propertyName !== pairName)
                     return false;
@@ -120,8 +182,34 @@ async function applyPropertyAttestationUidsFromPublish(params) {
         })
             .sort(compareMetadataRowsLatestFirst);
         const target = candidates.find((r) => isPlaceholderUid(r.uid));
-        if (!target?.localId)
+        if (!target?.localId) {
+            // Full snapshot: the property's rows are all attested. Record this attestation as a new row
+            // for the published version (unless it is already recorded, e.g. a replayed receipt).
+            const source = candidates[0];
+            if (!source || !validVersion)
+                continue;
+            if (working.some((r) => r.uid?.toLowerCase() === att.toLowerCase()))
+                continue;
+            const now = Date.now();
+            const row = {
+                ...source,
+                localId: generateId(),
+                uid: att,
+                schemaUid: normalizeBytes32Hex(source.schemaUid) ? source.schemaUid : wantSchema,
+                seedUid: liveSeedUid,
+                versionUid: validVersion,
+                versionLocalId: versionLocalId ?? source.versionLocalId,
+                attestationCreatedAt: attestationCreatedAtMs ?? now,
+                attestationRaw: null,
+                revokedAt: null,
+                derivedFromUid: null,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await appDb.insert(metadata).values(row);
+            working.push(row);
             continue;
+        }
         const writeSchemaUid = !normalizeBytes32Hex(target.schemaUid);
         await appDb
             .update(metadata)
@@ -130,6 +218,7 @@ async function applyPropertyAttestationUidsFromPublish(params) {
             ...(writeSchemaUid && { schemaUid: wantSchema }),
             ...(attestationCreatedAtMs != null && { attestationCreatedAt: attestationCreatedAtMs }),
             ...(validVersion && { versionUid: validVersion }),
+            ...(versionLocalId && { versionLocalId }),
             updatedAt: Date.now(),
         })
             .where(eq(metadata.localId, target.localId));
@@ -141,6 +230,7 @@ async function applyPropertyAttestationUidsFromPublish(params) {
                 ...(writeSchemaUid && { schemaUid: wantSchema }),
                 attestationCreatedAt: attestationCreatedAtMs ?? working[i].attestationCreatedAt,
                 ...(validVersion && { versionUid: validVersion }),
+                ...(versionLocalId && { versionLocalId }),
             };
         }
     }
@@ -171,7 +261,8 @@ function resolveSeedIds$1(arg) {
 }
 /**
  * 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
+ * EAS attestation `uid` — local edit or missing post-publish UID backfill. Rows sync derived for
+ * ItemStorage properties (`derivedFromUid` set) count as published. **Not** equivalent to
  * draft vs onchain for the whole seed; use `getSeedPublishState` for that.
  */
 async function getPublishPendingDiff(arg) {
@@ -208,9 +299,8 @@ async function getPublishPendingDiff(arg) {
         const latest = list[0];
         if (!latest)
             continue;
-        const hasUid = isValidEasAttestationUid(latest.uid);
-        if (!hasUid) {
-            const prevWithUid = list.find((r) => isValidEasAttestationUid(r.uid));
+        if (!isPublishedMetadataRow(latest)) {
+            const prevWithUid = list.find(isPublishedMetadataRow);
             pendingProperties.push({
                 propertyName,
                 currentValue: latest.propertyValue ?? null,
@@ -259,7 +349,8 @@ function maxMs(a, b) {
 }
 /**
  * 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.
+ * on the newest **published** version row (`getLatestPublishedVersionRow`, which skips revoked
+ * versions), or on **any** metadata row.
  * Not the same as “no unpublished edits”; see `getPublishPendingDiff` for per-property head rows.
  */
 async function getSeedPublishState(arg) {
@@ -271,6 +362,7 @@ async function getSeedPublishState(arg) {
         versionAttestationUid: null,
         explorerUid: null,
         lastAttestedAtMs: null,
+        revokedAt: null,
     };
     if (!appDb || (!seedLocalId && !seedUid)) {
         return empty;
@@ -316,6 +408,7 @@ async function getSeedPublishState(arg) {
         versionAttestationUid,
         explorerUid,
         lastAttestedAtMs,
+        revokedAt: seedRow?.revokedAt ? seedRow.revokedAt : null,
     };
 }
 
@@ -437,7 +530,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-Br-bGNFO.js');
+    const getItemMod = await import('./getItem-CSfSok9f.js');
     const { getItem } = getItemMod;
     const processRelationOrImage = async (prop) => {
         const snapshot = prop.getService().getSnapshot();
@@ -456,8 +549,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('./ClientManager-ChcmUL47.js');
-                const _ns_0 = _mod_0.al;
+                const _mod_0 = await import('./Item-ZUAmf943.js');
+                const _ns_0 = _mod_0.Y;
                 const { getPropertyData } = _ns_0;
                 const meta = await getPropertyData({
                     propertyName: prop.propertyName,
@@ -515,606 +608,839 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
     return result;
 }
 
-/**
- * Counts seeds, property attestations, and Arweave upload bytes for a publish
- * without building transactions or requiring a valid payload.
- */
-const DATA_URI = /^data:[^;]+;base64,([\s\S]*)$/i;
-const matchesDataType = (actual, expected) => normalizeDataType(actual) === expected;
-function isZeroUid(uid) {
-    return !uid || uid === ZERO_BYTES32;
+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;
 }
-function isStorageTransactionPropertyName(name) {
-    return name === 'storageTransactionId' || name === 'storage_transaction_id';
+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';
+    }
 }
-/** Decoded byte length of a data-URI, or null if the string is not a base64 data URI. */
-function estimateDataUriByteLength(dataUri) {
-    const m = DATA_URI.exec((dataUri ?? '').trim());
-    if (!m)
-        return null;
-    const b64 = m[1].replace(/\s/g, '');
-    if (!b64)
-        return 0;
-    const padding = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0;
-    return Math.max(0, Math.floor((b64.length * 3) / 4) - padding);
+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 propertyContext(prop) {
-    const snapshot = prop.getService().getSnapshot();
-    return snapshot && 'context' in snapshot
-        ? (snapshot.context ?? null)
-        : null;
+function getAttr(node, name) {
+    const a = node.attrs?.find((x) => x.name === name);
+    return a?.value;
 }
-function getPublishValue(prop, context) {
-    const propertyDef = prop.propertyDef ?? context.propertyRecordSchema;
-    const isFileImageHtml = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.File) ||
-        matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Image) ||
-        matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Html);
-    const isJsonStorage = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Json) ||
-        matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Json);
-    const isRelation = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Relation);
-    const isStorageTransactionIdProp = isStorageTransactionPropertyName(prop.propertyName);
-    const preferPropertyValue = isFileImageHtml || isRelation || isJsonStorage || isStorageTransactionIdProp;
-    let value = preferPropertyValue
-        ? context.propertyValue
-        : (prop.value ?? context.propertyValue);
-    if (isRelation || isFileImageHtml || isJsonStorage) {
-        const pv = context.propertyValue;
-        if (typeof value === 'object' || value == null) {
-            if (typeof pv === 'string' && pv.trim())
-                value = pv.trim();
-            else if (pv && typeof pv === 'object' && typeof pv.seedLocalId === 'string') {
-                value = pv.seedLocalId;
+/**
+ * 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;
+}
+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 value;
+    return out;
 }
-function shouldAttestProperty(prop, forceFullSnapshot) {
-    if (INTERNAL_PROPERTY_NAMES.includes(prop.propertyName))
-        return false;
-    const context = propertyContext(prop);
-    if (!context)
-        return false;
-    const value = getPublishValue(prop, context);
-    if (value == null || value === '')
-        return false;
-    if (prop.uid && !forceFullSnapshot) {
-        const allowStorageTx = isStorageTransactionPropertyName(prop.propertyName) &&
-            typeof value === 'string' &&
-            value.trim() !== '';
-        if (!allowStorageTx)
-            return false;
+/**
+ * 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';
     }
-    return true;
 }
-function getStorageDirForDataType(dataType) {
-    switch (normalizeDataType(dataType)) {
-        case 'Image':
-            return BaseFileManager.getFilesPath('images');
-        case 'File':
-            return BaseFileManager.getFilesPath('files');
-        case 'Html':
-            return BaseFileManager.getFilesPath('html');
-        case 'Json':
-            return BaseFileManager.getFilesPath('json');
-        default:
-            return BaseFileManager.getFilesPath('images');
+/** 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;
 }
-async function addUpload(acc, seen, key, bytes) {
-    if (bytes <= 0 || seen.has(key))
-        return;
-    seen.add(key);
-    acc.uploadCount += 1;
-    acc.uploadBytes += bytes;
+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 addUploadFromPath(acc, seen, filePath, key) {
-    if (!filePath || filePath.endsWith('undefined'))
-        return;
-    const size = await BaseFileManager.getFileSize(filePath);
-    if (size == null || size <= 0)
+async function deleteCoPublishRowsForParent(appDb, parentSeedLocalId) {
+    if (!appDb)
         return;
-    await addUpload(acc, seen, key, size);
+    await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId));
 }
-async function collectUploadBytes(item, itemUploadProperties, itemImageProperties, relatedItemProperty, acc, seen) {
-    for (const uploadProperty of itemUploadProperties) {
-        let childBytes = 0;
-        let childCount = 0;
-        for (const childProperty of uploadProperty.childProperties) {
-            const filePath = childProperty.localStoragePath;
-            if (!filePath || filePath.endsWith('undefined'))
-                continue;
-            const size = await BaseFileManager.getFileSize(filePath);
-            if (size == null || size <= 0)
-                continue;
-            childBytes += size;
-            childCount += 1;
-        }
-        if (childCount > 0) {
-            await addUpload(acc, seen, `upload:${item.seedLocalId}:${uploadProperty.itemProperty.localId}`, childBytes);
-            continue;
-        }
-    }
-    for (const itemProperty of itemImageProperties) {
-        const context = propertyContext(itemProperty);
-        if (!context)
-            continue;
-        const refResolvedValue = (typeof context.refResolvedValue === 'string' && context.refResolvedValue) ||
-            itemProperty.refResolvedValue;
-        if (typeof refResolvedValue !== 'string' || !refResolvedValue)
-            continue;
-        const propertyValue = context.propertyValue;
-        const { seedLocalId } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
-        const dataType = itemProperty.propertyDef?.refValueType ??
-            itemProperty.propertyDef?.dataType ??
-            'Image';
-        const fromGetter = itemProperty.localStoragePath;
-        const filePath = typeof fromGetter === 'string' && fromGetter
-            ? fromGetter
-            : `${getStorageDirForDataType(String(dataType))}/${refResolvedValue}`;
-        await addUploadFromPath(acc, seen, filePath, seedLocalId ? `seed:${seedLocalId}` : `path:${filePath}`);
+/**
+ * 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',
+        modelFileId: INTERNAL_STORAGE_MODEL_FILE_IDS.image,
+    });
+    await waitForEntityIdle(imageItem, { timeout: 60000 });
+    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 };
 }
-async function loadRelatedItem(value) {
-    const normalized = normalizeRelationPropertyValue(value);
-    if (!normalized)
-        return undefined;
-    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalized);
-    if (!seedLocalId && !seedUid)
-        return undefined;
-    const { getItem } = await import('./getItem-Br-bGNFO.js');
-    try {
-        return await getItem({ seedLocalId, seedUid });
+/**
+ * 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: [] };
     }
-    catch {
-        return undefined;
+    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] };
 }
-async function relatedIfUnpublished(prop) {
-    const context = propertyContext(prop);
-    if (!context)
-        return undefined;
-    const related = await loadRelatedItem(context.propertyValue);
-    if (!related || !isZeroUid(related.seedUid))
-        return undefined;
-    return related;
+/**
+ * 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_1 = await import('./publishDraftGraph-BRm6Pq3Q.js');
+    const _ns_1 = _mod_1.p;
+    const { getPublishDraftGraph } = _ns_1;
+    const { drafts } = await getPublishDraftGraph(item);
+    return drafts.map((d) => d.item);
 }
-async function unpublishedListItems(listProperty) {
-    const context = propertyContext(listProperty);
-    if (!context)
-        return [];
-    let value = context.propertyValue;
-    if (!value)
-        return [];
-    if (typeof value === 'string') {
-        value = parseListPropertyValueFromStorage(value);
-    }
-    const arr = Array.isArray(value) ? value : [];
-    const out = [];
-    for (const seedId of arr) {
-        const related = await loadRelatedItem(seedId);
-        if (related && isZeroUid(related.seedUid))
-            out.push(related);
+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 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 out;
 }
-async function appendCoPublishImages(item, acc, seen, visited, forceFullSnapshot, publishMode) {
+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, item.seedLocalId));
-    for (const row of rows) {
-        const _mod_1 = await import('./ClientManager-ChcmUL47.js');
-        const _ns_1 = _mod_1.am;
-        const { Item } = _ns_1;
-        const imageItem = await Item.find({
-            seedLocalId: row.imageSeedLocalId,
-            modelName: 'Image',
-        });
-        if (!imageItem)
+        .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 st = imageItem.internalProperties['storageTransactionId'] ??
-            imageItem.allProperties['storageTransactionId'];
-        const stCtx = st ? propertyContext(st) : null;
-        const stValue = typeof stCtx?.propertyValue === 'string' ? stCtx.propertyValue : '';
-        const dataUriBytes = estimateDataUriByteLength(stValue);
-        if (dataUriBytes != null && dataUriBytes > 0) {
-            await addUpload(acc, seen, `seed:${imageItem.seedLocalId}`, dataUriBytes);
-        }
-        await summarizeItem(imageItem, publishMode, forceFullSnapshot, acc, seen, visited);
-    }
-}
-async function summarizeItem(item, publishMode, forceFullSnapshot, acc, seenUploads, visited) {
-    const seedLocalId = item.seedLocalId;
-    if (!seedLocalId || visited.has(seedLocalId))
-        return;
-    visited.add(seedLocalId);
-    acc.seedCount += 1;
-    if (isZeroUid(item.seedUid))
-        acc.newSeedCount += 1;
-    if (isZeroUid(item.seedUid) || forceFullSnapshot)
-        acc.newVersionCount += 1;
-    const { itemBasicProperties, itemRelationProperties, itemListProperties, itemUploadProperties, itemImageProperties, } = await getSegmentedItemProperties(item);
-    await collectUploadBytes(item, itemUploadProperties, itemImageProperties, undefined, acc, seenUploads);
-    for (const rel of itemRelationProperties) {
-        const related = await relatedIfUnpublished(rel);
-        if (related) {
-            await summarizeItem(related, publishMode, forceFullSnapshot, acc, seenUploads, visited);
+        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));
         }
-    }
-    for (const listProperty of itemListProperties) {
-        for (const related of await unpublishedListItems(listProperty)) {
-            await summarizeItem(related, publishMode, forceFullSnapshot, acc, seenUploads, visited);
+        const urlByPropertyName = new Map();
+        for (const name of findSeedPropertyRefsInHtml(html)) {
+            const txId = await resolveSeedPropertyRefTxId(parentItem, name, txBySeedLocalId);
+            urlByPropertyName.set(name, getArweaveUrlForTransaction(txId));
         }
-    }
-    await appendCoPublishImages(item, acc, seenUploads, visited, forceFullSnapshot, publishMode);
-    const attestable = [
-        ...itemBasicProperties,
-        ...itemRelationProperties,
-        ...itemListProperties,
-        ...itemImageProperties,
-        ...itemUploadProperties.map((u) => u.itemProperty),
-    ];
-    const seenProps = new Set();
-    for (const prop of attestable) {
-        const key = prop.localId || `${prop.propertyName}:${prop.seedLocalId}`;
-        if (seenProps.has(key))
+        const newHtml = replaceSeedPropertyRefsInHtml(replaceDataUrisInParsedHtml(html, replacements), urlByPropertyName);
+        if (newHtml === html)
             continue;
-        seenProps.add(key);
-        if (shouldAttestProperty(prop, forceFullSnapshot))
-            acc.attestationCount += 1;
+        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;
+}
 /**
- * Local measurement of what a publish would do: seed/version/attestation counts
- * and Arweave upload byte totals. Does not hit the network or create transactions.
+ * Remove co-publish rows after a successful publish for this parent seed.
  */
-const summarizePublishWork = async (item, options) => {
-    const publishMode = options?.publishMode ?? 'patch';
-    const forceFullSnapshot = publishMode === 'new_version';
-    const acc = {
-        publishMode,
-        seedCount: 0,
-        newSeedCount: 0,
-        newVersionCount: 0,
-        attestationCount: 0,
-        uploadCount: 0,
-        uploadBytes: 0,
-    };
-    await summarizeItem(item, publishMode, forceFullSnapshot, acc, new Set(), new Set());
-    return acc;
-};
-
-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;
+async function clearHtmlEmbeddedImageCoPublishRows(parentSeedLocalId) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !parentSeedLocalId)
+        return;
+    await appDb
+        .delete(htmlEmbeddedImageCoPublish)
+        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId.trim()));
 }
-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';
-    }
+
+/**
+ * Counts seeds, property attestations, and Arweave upload bytes for a publish
+ * without building transactions or requiring a valid payload.
+ */
+const DATA_URI = /^data:[^;]+;base64,([\s\S]*)$/i;
+const matchesDataType = (actual, expected) => normalizeDataType(actual) === expected;
+function isZeroUid(uid) {
+    return !uid || uid === ZERO_BYTES32;
 }
-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 isStorageTransactionPropertyName(name) {
+    return name === 'storageTransactionId' || name === 'storage_transaction_id';
 }
-function getAttr(node, name) {
-    const a = node.attrs?.find((x) => x.name === name);
-    return a?.value;
+/** Decoded byte length of a data-URI, or null if the string is not a base64 data URI. */
+function estimateDataUriByteLength(dataUri) {
+    const m = DATA_URI.exec((dataUri ?? '').trim());
+    if (!m)
+        return null;
+    const b64 = m[1].replace(/\s/g, '');
+    if (!b64)
+        return 0;
+    const padding = b64.endsWith('==') ? 2 : b64.endsWith('=') ? 1 : 0;
+    return Math.max(0, Math.floor((b64.length * 3) / 4) - padding);
 }
-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 });
+function propertyContext(prop) {
+    const snapshot = prop.getService().getSnapshot();
+    return snapshot && 'context' in snapshot
+        ? (snapshot.context ?? null)
+        : null;
 }
-/**
- * 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 });
-                    }
-                }
+function getPublishValue(prop, context) {
+    const propertyDef = prop.propertyDef ?? context.propertyRecordSchema;
+    const isFileImageHtml = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.File) ||
+        matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Image) ||
+        matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Html);
+    const isJsonStorage = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Json) ||
+        matchesDataType(propertyDef?.refValueType, ModelPropertyDataTypes.Json);
+    const isRelation = matchesDataType(propertyDef?.dataType, ModelPropertyDataTypes.Relation);
+    const isStorageTransactionIdProp = isStorageTransactionPropertyName(prop.propertyName);
+    const preferPropertyValue = isFileImageHtml || isRelation || isJsonStorage || isStorageTransactionIdProp;
+    let value = preferPropertyValue
+        ? context.propertyValue
+        : (prop.value ?? context.propertyValue);
+    if (isRelation || isFileImageHtml || isJsonStorage) {
+        const pv = context.propertyValue;
+        if (typeof value === 'object' || value == null) {
+            if (typeof pv === 'string' && pv.trim())
+                value = pv.trim();
+            else if (pv && typeof pv === 'object' && typeof pv.seedLocalId === 'string') {
+                value = pv.seedLocalId;
             }
         }
-        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;
+    }
+    return value;
 }
-/**
- * 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);
+function shouldAttestProperty(prop, forceFullSnapshot) {
+    if (INTERNAL_PROPERTY_NAMES.includes(prop.propertyName))
+        return false;
+    const context = propertyContext(prop);
+    if (!context)
+        return false;
+    const value = getPublishValue(prop, context);
+    if (value == null || value === '')
+        return false;
+    if (prop.uid && !forceFullSnapshot) {
+        const allowStorageTx = isStorageTransactionPropertyName(prop.propertyName) &&
+            typeof value === 'string' &&
+            value.trim() !== '';
+        if (!allowStorageTx)
+            return false;
+    }
+    return true;
 }
-async function deleteCoPublishRowsForParent(appDb, parentSeedLocalId) {
-    if (!appDb)
+function getStorageDirForDataType(dataType) {
+    switch (normalizeDataType(dataType)) {
+        case 'Image':
+            return BaseFileManager.getFilesPath('images');
+        case 'File':
+            return BaseFileManager.getFilesPath('files');
+        case 'Html':
+            return BaseFileManager.getFilesPath('html');
+        case 'Json':
+            return BaseFileManager.getFilesPath('json');
+        default:
+            return BaseFileManager.getFilesPath('images');
+    }
+}
+async function addUpload(acc, seen, key, bytes) {
+    if (bytes <= 0 || seen.has(key))
         return;
-    await appDb.delete(htmlEmbeddedImageCoPublish).where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId));
+    seen.add(key);
+    acc.uploadCount += 1;
+    acc.uploadBytes += bytes;
 }
-/**
- * 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 });
-    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 };
+async function addUploadFromPath(acc, seen, filePath, key) {
+    if (!filePath || filePath.endsWith('undefined'))
+        return;
+    const size = await BaseFileManager.getFileSize(filePath);
+    if (size == null || size <= 0)
+        return;
+    await addUpload(acc, seen, key, size);
 }
-/**
- * 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)
+async function collectUploadBytes(item, itemUploadProperties, itemImageProperties, relatedItemProperty, acc, seen) {
+    for (const uploadProperty of itemUploadProperties) {
+        let childBytes = 0;
+        let childCount = 0;
+        for (const childProperty of uploadProperty.childProperties) {
+            const filePath = childProperty.localStoragePath;
+            if (!filePath || filePath.endsWith('undefined'))
+                continue;
+            const size = await BaseFileManager.getFileSize(filePath);
+            if (size == null || size <= 0)
+                continue;
+            childBytes += size;
+            childCount += 1;
+        }
+        if (childCount > 0) {
+            await addUpload(acc, seen, `upload:${item.seedLocalId}:${uploadProperty.itemProperty.localId}`, childBytes);
             continue;
-        const policy = resolveEffectiveHtmlEmbeddedDataUriPolicy(def, publishPolicy);
-        if (policy !== 'materialize')
+        }
+    }
+    for (const itemProperty of itemImageProperties) {
+        const context = propertyContext(itemProperty);
+        if (!context)
             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)
+        const refResolvedValue = (typeof context.refResolvedValue === 'string' && context.refResolvedValue) ||
+            itemProperty.refResolvedValue;
+        if (typeof refResolvedValue !== 'string' || !refResolvedValue)
             continue;
-        const filePath = `${BaseFileManager.getFilesPath('html')}/${refResolved}`;
-        const exists = await BaseFileManager.pathExists(filePath);
-        if (!exists)
+        const propertyValue = context.propertyValue;
+        const { seedLocalId } = resolveSeedIdsFromRefString(normalizeRelationPropertyValue(propertyValue) ?? '');
+        const dataType = itemProperty.propertyDef?.refValueType ??
+            itemProperty.propertyDef?.dataType ??
+            'Image';
+        const fromGetter = itemProperty.localStoragePath;
+        const filePath = typeof fromGetter === 'string' && fromGetter
+            ? fromGetter
+            : `${getStorageDirForDataType(String(dataType))}/${refResolvedValue}`;
+        await addUploadFromPath(acc, seen, filePath, seedLocalId ? `seed:${seedLocalId}` : `path:${filePath}`);
+    }
+}
+async function loadRelatedItem(value) {
+    const normalized = normalizeRelationPropertyValue(value);
+    if (!normalized)
+        return undefined;
+    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalized);
+    if (!seedLocalId && !seedUid)
+        return undefined;
+    const { getItem } = await import('./getItem-CSfSok9f.js');
+    try {
+        return await getItem({ seedLocalId, seedUid });
+    }
+    catch {
+        return undefined;
+    }
+}
+async function relatedIfUnpublished(prop) {
+    const context = propertyContext(prop);
+    if (!context)
+        return undefined;
+    const related = await loadRelatedItem(context.propertyValue);
+    if (!related || !isZeroUid(related.seedUid))
+        return undefined;
+    return related;
+}
+/** Seed refs held by a relation/image property (one) or a list property (each member). */
+function seedRefsOf(prop, isList) {
+    const context = propertyContext(prop);
+    if (!context)
+        return [];
+    let value = context.propertyValue;
+    if (isList) {
+        if (typeof value === 'string')
+            value = parseListPropertyValueFromStorage(value);
+        return (Array.isArray(value) ? value : [])
+            .map((v) => normalizeRelationPropertyValue(v))
+            .filter((v) => !!v);
+    }
+    const ref = normalizeRelationPropertyValue(value);
+    return ref ? [ref] : [];
+}
+/** Like getPublishPayload: attested refs to revoked seeds block the publish. */
+async function collectUnpublishedRelatedItems(props, isList, forceFullSnapshot, out, backReferences) {
+    for (const prop of props) {
+        if (!shouldAttestProperty(prop, forceFullSnapshot))
             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));
+        for (const ref of seedRefsOf(prop, isList)) {
+            const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
+            if (!seedLocalId && !seedUid)
+                continue;
+            const row = await findRelatedSeedRow({ seedLocalId, seedUid });
+            // A back reference to a seed this publish creates (e.g. a revoked root published again) is
+            // left for a later publish, not attested (publishDraftGraph.ts)
+            if (row && backReferences?.get(prop)?.has(row.seedLocalId))
+                continue;
+            if (!isUnpublishedSeed(row))
+                continue;
+            if (out.some((r) => r.propertyName === prop.propertyName && r.seedLocalId === row.seedLocalId)) {
+                continue;
             }
-        }
-        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();
+            const related = await loadRelatedItem(row.seedLocalId);
+            out.push({
+                propertyName: prop.propertyName,
+                modelName: related?.modelName ?? relatedModelNameFromDef(prop.propertyDef) ?? row.type ?? 'unknown',
+                seedLocalId: row.seedLocalId,
+                seedUid: row.seedUid,
+            });
         }
     }
-    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.
+ * Images embedded in Html properties (co-published) whose seed was revoked: getPublishPayload rejects
+ * them like image properties pointing at revoked seeds. Like getPublishPayload, checks the published
+ * item's co-publish rows and those of the draft items published with it.
  */
-async function rewriteHtmlEmbeddedImagesOnDisk(parentSeedLocalId, uploadedTransactions) {
+async function collectUnpublishedEmbeddedImages(item, out) {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !item.seedLocalId)
+        return;
+    for (const owner of [item, ...(await getRelatedDraftsCoPublishedWith(item))]) {
+        const rows = await appDb
+            .select()
+            .from(htmlEmbeddedImageCoPublish)
+            .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, owner.seedLocalId));
+        for (const row of rows) {
+            const seed = await findRelatedSeedRow({ seedLocalId: row.imageSeedLocalId });
+            if (!isUnpublishedSeed(seed))
+                continue;
+            const propertyName = htmlPropertyNameForHtmlSeed(owner, row.htmlSeedLocalId);
+            if (out.some((r) => r.propertyName === propertyName && r.seedLocalId === seed.seedLocalId))
+                continue;
+            out.push({ propertyName, modelName: 'Image', seedLocalId: seed.seedLocalId, seedUid: seed.seedUid });
+        }
+    }
+}
+async function appendCoPublishImages(item, acc, seen, visited, forceFullSnapshot, publishMode, graph) {
     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());
+        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, item.seedLocalId));
+    for (const row of rows) {
+        const _mod_2 = await import('./Item-ZUAmf943.js');
+        const _ns_2 = _mod_2.Z;
+        const { Item } = _ns_2;
+        const imageItem = await Item.find({
+            seedLocalId: row.imageSeedLocalId,
+            modelName: 'Image',
+        });
+        // Like getPublishPayload: an embedded image that already has a seed (published, or unpublished
+        // and reported by collectUnpublishedEmbeddedImages) is not co-published.
+        if (!imageItem || !isZeroUid(imageItem.seedUid))
+            continue;
+        const st = imageItem.internalProperties['storageTransactionId'] ??
+            imageItem.allProperties['storageTransactionId'];
+        const stCtx = st ? propertyContext(st) : null;
+        const stValue = typeof stCtx?.propertyValue === 'string' ? stCtx.propertyValue : '';
+        const dataUriBytes = estimateDataUriByteLength(stValue);
+        if (dataUriBytes != null && dataUriBytes > 0) {
+            await addUpload(acc, seen, `seed:${imageItem.seedLocalId}`, dataUriBytes);
         }
+        await summarizeItem(imageItem, publishMode, forceFullSnapshot, acc, seen, visited, graph);
     }
-    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);
+}
+async function summarizeItem(item, publishMode, forceFullSnapshot, acc, seenUploads, visited, graph) {
+    const seedLocalId = item.seedLocalId;
+    if (!seedLocalId || visited.has(seedLocalId))
+        return;
+    visited.add(seedLocalId);
+    acc.seedCount += 1;
+    if (isZeroUid(item.seedUid))
+        acc.newSeedCount += 1;
+    if (isZeroUid(item.seedUid) || forceFullSnapshot)
+        acc.newVersionCount += 1;
+    const { itemBasicProperties, itemRelationProperties, itemListProperties, itemUploadProperties, itemImageProperties, } = await getSegmentedItemProperties(item);
+    await collectUploadBytes(item, itemUploadProperties, itemImageProperties, undefined, acc, seenUploads);
+    await collectUnpublishedRelatedItems([...itemRelationProperties, ...itemImageProperties], false, forceFullSnapshot, acc.unpublishedRelatedItems, graph.backReferences);
+    await collectUnpublishedRelatedItems(itemListProperties, true, forceFullSnapshot, acc.unpublishedRelatedItems, graph.backReferences);
+    // Draft Image/File/Html/Json items its storage relations point at. Draft model items its relations
+    // and lists reach are summarized by summarizePublishWork from the publish's draft graph.
+    const storageProperties = new Set(itemImageProperties);
+    for (const rel of itemRelationProperties) {
+        if (!storageProperties.has(rel))
+            continue;
+        const related = await relatedIfUnpublished(rel);
+        if (related) {
+            await summarizeItem(related, publishMode, forceFullSnapshot, acc, seenUploads, visited, graph);
         }
     }
-    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)))
+    await appendCoPublishImages(item, acc, seenUploads, visited, forceFullSnapshot, publishMode, graph);
+    const attestable = [
+        ...itemBasicProperties,
+        ...itemRelationProperties,
+        ...itemListProperties,
+        ...itemImageProperties,
+        ...itemUploadProperties.map((u) => u.itemProperty),
+    ];
+    const seenProps = new Set();
+    for (const prop of attestable) {
+        const key = prop.localId || `${prop.propertyName}:${prop.seedLocalId}`;
+        if (seenProps.has(key))
             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)
+        seenProps.add(key);
+        // A ref back to an item this publish creates is left for a later publish (publishDraftGraph.ts).
+        if (graph.deferredProperties.has(prop))
             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,
-                    });
-                }
-            }
-        }
+        if (shouldAttestProperty(prop, forceFullSnapshot))
+            acc.attestationCount += 1;
     }
 }
-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.
+ * Local measurement of what a publish would do: seed/version/attestation counts
+ * and Arweave upload byte totals. Does not hit the network or create transactions.
  */
-async function clearHtmlEmbeddedImageCoPublishRows(parentSeedLocalId) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb || !parentSeedLocalId)
-        return;
-    await appDb
-        .delete(htmlEmbeddedImageCoPublish)
-        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, parentSeedLocalId.trim()));
+const publishForcesFullSnapshot = async (item, publishMode) => {
+    // Like getPublishPayload: an item whose seed was revoked republishes as a new seed with a full
+    // snapshot.
+    const republishRevokedSeed = !isZeroUid(item.seedUid) && (await isSeedRevoked(item.seedLocalId));
+    return { republishRevokedSeed, forceFullSnapshot: publishMode === 'new_version' || republishRevokedSeed };
+};
+async function collectUnpublishedRelatedItemsOf(item, forceFullSnapshot, out, backReferences) {
+    const { itemRelationProperties, itemListProperties, itemImageProperties } = await getSegmentedItemProperties(item);
+    await collectUnpublishedRelatedItems([...itemRelationProperties, ...itemImageProperties], false, forceFullSnapshot, out, backReferences);
+    await collectUnpublishedRelatedItems(itemListProperties, true, forceFullSnapshot, out, backReferences);
 }
+/**
+ * References a publish of `item` would attest to items whose seed was unpublished (revoked), the
+ * same ones getPublishPayload rejects with RelatedItemUnpublishedError. Local reads only: the
+ * publish package checks this before registering schemas or uploading anything.
+ */
+const getUnpublishedRelatedItems = async (item, options) => {
+    const { forceFullSnapshot } = await publishForcesFullSnapshot(item, options?.publishMode ?? 'patch');
+    const out = [];
+    // The item and every draft its publish carries along (publishDraftGraph.ts).
+    const { drafts, backReferences } = await getPublishDraftGraph(item, { forceFullSnapshot });
+    for (const owner of [item, ...drafts.map((d) => d.item)]) {
+        await collectUnpublishedRelatedItemsOf(owner, forceFullSnapshot, out, backReferences);
+    }
+    await collectUnpublishedEmbeddedImages(item, out);
+    return out;
+};
+const summarizePublishWork = async (item, options) => {
+    const publishMode = options?.publishMode ?? 'patch';
+    const { republishRevokedSeed, forceFullSnapshot } = await publishForcesFullSnapshot(item, publishMode);
+    const acc = {
+        publishMode,
+        seedCount: 0,
+        newSeedCount: 0,
+        newVersionCount: 0,
+        attestationCount: 0,
+        uploadCount: 0,
+        uploadBytes: 0,
+        unpublishedRelatedItems: [],
+    };
+    const graph = await getPublishDraftGraph(item, { forceFullSnapshot });
+    const { drafts } = graph;
+    const seenUploads = new Set();
+    const visited = new Set();
+    for (const owner of [item, ...drafts.map((d) => d.item)]) {
+        await summarizeItem(owner, publishMode, forceFullSnapshot, acc, seenUploads, visited, graph);
+    }
+    await collectUnpublishedEmbeddedImages(item, acc.unpublishedRelatedItems);
+    // summarizeItem counts the root as an existing seed (it has a seedUid).
+    if (republishRevokedSeed)
+        acc.newSeedCount += 1;
+    return acc;
+};
 
-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, estimateDataUriByteLength, extractDataUriImagesFromHtml, getArweaveUrlForTransaction, getAttesterForSeed, getMetadataAttestationUidsForSeedUid, getPublishPendingDiff, getRelatedItemsForPublish, getSeedPublishState, getSegmentedItemProperties, getVersionsForSeedUid, htmlEmbeddedImageCoPublish, isDataType, metadata, normalizeDataType, normalizePublisher, normalizeRelationPropertyValue, prepareHtmlEmbeddedImagesForPublish, replaceDataUrisInParsedHtml, resolveEffectiveHtmlEmbeddedDataUriPolicy, resolveSeedIdsFromRefString, rewriteHtmlEmbeddedImagesOnDisk, seeds, shouldAttestProperty, summarizePublishWork, updateVersionUid, versions, waitForEntityIdle };
+export { BaseDb, BaseFileManager, BaseFileManager as FileManager, HTML_EMBEDDED_MAX_IMAGES_PER_DOC, HTML_EMBEDDED_MAX_IMAGE_BYTES, HTML_EMBEDDED_MAX_TOTAL_BYTES, HtmlEmbeddedDataUriLimitError, HtmlSeedPropertyRefError, Item, ModelPropertyDataTypes, SEED_PROPERTY_REF_PREFIX, applyArweaveL1TransactionIdLocal, applyPropertyAttestationUidsFromPublish, clearHtmlEmbeddedImageCoPublishRows, compareMetadataRowsLatestFirst, estimateDataUriByteLength, extractDataUriImagesFromHtml, findSeedPropertyRefsInHtml, generateId, getArweaveUrlForTransaction, getAttesterForSeed, getMetadataAttestationUidsForSeedUid, getPublishDraftGraph, getPublishPendingDiff, getRelatedItemsForPublish, getSeedPublishState, getSegmentedItemProperties, getUnpublishedRelatedItems, getVersionsForSeedUid, htmlEmbeddedImageCoPublish, isDataType, metadata, normalizeDataType, normalizePublisher, normalizeRelationPropertyValue, prepareHtmlEmbeddedImagesForPublish, replaceDataUrisInParsedHtml, replaceSeedPropertyRefsInHtml, resolveEffectiveHtmlEmbeddedDataUriPolicy, resolveSeedIdsFromRefString, rewriteHtmlEmbeddedImagesOnDisk, seeds, shouldAttestProperty, summarizePublishWork, updateVersionUid, versions, waitForEntityIdle };
 //# sourceMappingURL=main.js.map