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

package/dist/main.js

@@ -1,1117 +1,35 @@
-export { C as ConflictError, d as ItemCreateError, I as ItemCreateValidationError, M as Model, U as UnknownModelError } from './errors-D1zHAqjr.js';
-import { L as BaseDb, v as versions, a8 as normalizePublisher, s as seeds, ad as generateId, m as metadata, p as models, E as properties, n as normalizeDataType, a6 as listRelationEasPropertyName, q as normalizeRelationPropertyValue, r as resolveSeedIdsFromRefString, i as isDataType, M as ModelPropertyDataTypes, a2 as INTERNAL_PROPERTY_NAMES, x as htmlEmbeddedImageCoPublish, a0 as ZERO_BYTES32, Q as BaseFileManager, W as getStorageDirForDataType } from './index-Dx_GTdyQ.js';
-export { A as AmbiguousModelError, an as CONTENT_SHA256_TAG, ao as CONTENT_TYPE_TAG, ac as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, a5 as INTERNAL_DATA_TYPES, ap as ImageSize, aq as SEED_PROTOCOL_SCHEMA_NAME, ar as SeedModels, as as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, h as appState, t as arweaveL1FinalizeJobs, Y as buildArweaveContentTags, at as classifyMediaRef, au as closestImageSize, av as contentSha256TagMatches, a7 as easPropertyNameForPublish, u as easSyncProcesses, aw as ensureImageLocal, ax as getAddressesForItemsFilter, ay as getArweaveUrlForTransaction, X as getContentSha256, k as getCorrectId, az as getFeedItemStringField, l as isPublishedSeedRef, z as modelSchemas, o as modelUids, aA as normalizeAddressConfig, aB as normalizeAddressList, aC as normalizeArweaveTxIdForEnsure, aD as normalizeFeedItemFields, ae as normalizeHexAddress, H as propertyUids, I as publishProcesses, aE as resolveMediaRef, J as schemas, K as uploadProcesses } from './index-Dx_GTdyQ.js';
-export { getPropertySchema } from './property-BwYtg5Q_.js';
-export { e as eventEmitter } from './eventBus-7vxTCc3a.js';
-export { A as ADDRESSES_PERSISTED_EVENT, F as FILES_CHANGED_EVENT, L as LOCAL_COPIES_REMOVED_EVENT, T as TabLockTimeoutError, i as isChangeFeedRunning, a as isLeaderTab, p as parseAddressesPersistedPayload, w as watchEntityChanges, b as watchEntityRows, c as whenLeaderTab } from './changeFeed-DKdVlUmt.js';
-export { E as EAS_CHAIN_ID_APP_STATE_KEY, I as INIT_CONFIG_CONFLICT_MESSAGE, o as assertLocalDbChain, p as claimUnpublishedDrafts, C as client, q as createLocalQueryDataSource, u as easSyncActor, v as getClient, x as getPublishedSeedRecord, y as getSchemaNameFromId, i as importJsonSchema, z as isSeedQueryLocalSourceRegistered, A as listSchemas, B as loadAllSchemasFromDb, D as mergeEasSyncRequestIntents, r as readJsonImportFile, F as registerSeedQueryLocalSource, G as requestEasSyncFromAddressChange, H as requestEasSyncFromModelsInit, J as sendEasSyncClientRequest, K as setRetriesWhenOnlineEnabled, L as startEasSyncActor, j as syncSchemaFromSource, k as transformImportToSchemaFile, M as unregisterSeedQueryLocalSource } from './ClientManager-GZfXErDX.js';
-import { U as latestVersionOrder, K as isVersionRevoked, C as compareMetadataRowsLatestFirst, F as parseListPropertyValueFromStorage, V as isPublishedMetadataRow, E as getLatestPublishedVersionRow } from './Item-0oDoTPhi.js';
-export { W as ClientManagerState, I as Item, q as ItemProperty, t as ItemPropertySaveValidationError, M as METADATA_LATEST_FIRST_ORDER_SQL, X as MachineIds, u as OwnershipError, Y as PUBLISH_NOT_CONFIGURED_MESSAGE, v as assertItemOwned, Z as createNewItem, J as getGetAdditionalSyncAddresses, _ as getGetPublisherForNewSeeds, $ as getMetadataLatest, a0 as getPublishExecutor, a1 as getRevokeExecutor, a2 as getUploadExecutor, a3 as getVersionData, x as isItemOwned, a4 as isLocalUnsealedDraft, a5 as isSeedRowOwned, a6 as localUnsealedDraftSql, a7 as ownedPublisherSql, a8 as ownedSeedsSql, a9 as pickLatestMetadataRowPerProperty, aa as placeholderUidSql, ab as propertyMachine, ac as publisherInAddressListSql, ad as publisherIsInOwnedSet, ae as setAdditionalSyncAddresses, af as setGetPublisherForNewSeeds, ag as setPublishExecutor, ah as setRevokeExecutor, ai as setUploadExecutor, B as waitForEntityIdle } from './Item-0oDoTPhi.js';
-import { eq, and, inArray, or, isNotNull, ne } from 'drizzle-orm';
-import { isPlaceholderUid, isValidEasAttestationUid, normalizeBytes32Hex, easName, BaseQueryClient, BaseEasClient, GET_SCHEMAS } from '@seedprotocol/eas';
-export { EAS_CHAIN_DEPLOYMENTS, BaseEasClient as EasClient, VERSION_SCHEMA_DEF, VERSION_SCHEMA_UID, easName, getCanonicalItemPropertiesFromEas, getEasChainDeployment, getEasEndpoint, getEasReadChainId, getEasSchemaUidBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getSeedsBySchemaName, getSeedsFromSchemaUids, isPlaceholderUid, isValidEasAttestationUid, matchEasName, normalizeBytes32Hex, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForModel, setSchemaUidForSchemaDefinition, withExcludeRevokedFilter } from '@seedprotocol/eas';
-export { S as Schema, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-PFZwG9Nl.js';
+export { C as ConflictError, G as EAS_CHAIN_ID_APP_STATE_KEY, H as INIT_CONFIG_CONFLICT_MESSAGE, J as ItemCreateError, I as ItemCreateValidationError, M as Model, U as UnknownModelError, B as assertLocalDbChain, K as claimUnpublishedDrafts, g as client, L as createLocalQueryDataSource, N as easSyncActor, O as getClient, P as getPublishedSeedRecord, Q as getSchemaNameFromId, i as importJsonSchema, V as isSeedQueryLocalSourceRegistered, W as listSchemas, q as loadAllSchemasFromDb, X as mergeEasSyncRequestIntents, r as readJsonImportFile, Y as registerSeedQueryLocalSource, Z as requestEasSyncFromAddressChange, _ as requestEasSyncFromModelsInit, $ as sendEasSyncClientRequest, a0 as setRetriesWhenOnlineEnabled, a1 as startEasSyncActor, h as syncSchemaFromSource, j as transformImportToSchemaFile, a2 as unregisterSeedQueryLocalSource } from './errors-DLSoqSHG.js';
+export { a8 as ADDRESSES_PERSISTED_EVENT, A as AmbiguousModelError, a9 as CONTENT_SHA256_TAG, aa as CONTENT_TYPE_TAG, ab as ClientManagerState, Q as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, ac as FILES_CHANGED_EVENT, v as INTERNAL_DATA_TYPES, ad as ImageSize, ae as LOCAL_COPIES_REMOVED_EVENT, af as MachineIds, M as ModelPropertyDataTypes, S as SEED_PROTOCOL_SCHEMA_NAME, ag as SeedModels, ah as TabLockTimeoutError, ai as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, X as buildArweaveContentTags, aj as closestImageSize, ak as contentSha256TagMatches, al as ensureImageLocal, h as eventEmitter, m as generateId, am as getAddressesForItemsFilter, W as getContentSha256, an as isChangeFeedRunning, s as isClientReady, ao as isClientReadySnapshot, i as isDataType, ap as isLeaderTab, aq as normalizeAddressConfig, ar as normalizeAddressList, as as normalizeArweaveTxIdForEnsure, n as normalizeDataType, J as normalizeHexAddress, x as normalizePublisher, at as parseAddressesPersistedPayload, au as watchEntityChanges, av as watchEntityRows, aw as whenDbReady, ax as whenLeaderTab } from './tabEvents-CaVmngqr.js';
+export { getPropertySchema } from './property-BxUYznH0.js';
+export { B as BaseDb, w as BaseFileManager, w as FileManager, a as appState, e as arweaveL1FinalizeJobs, f as easSyncProcesses, h as htmlEmbeddedImageCoPublish, m as metadata, j as modelSchemas, b as modelUids, d as models, l as properties, q as propertyUids, r as publishProcesses, t as schemas, s as seeds, u as uploadProcesses, v as versions } from './BaseFileManager-BAlySv8w.js';
+export { C as ClearNotSupportedError, I as Item, v as ItemProperty, x as ItemPropertySaveValidationError, ag as METADATA_LATEST_FIRST_ORDER_SQL, y as OwnershipError, as as PUBLISH_NOT_CONFIGURED_MESSAGE, z as assertItemOwned, H as compareMetadataRowsLatestFirst, at as createNewItem, a9 as easPropertyNameForPublish, au as getArweaveUrlForTransaction, A as getCorrectId, a6 as getGetAdditionalSyncAddresses, av as getGetPublisherForNewSeeds, aw as getMetadataLatest, ax as getPublishExecutor, ay as getRevokeExecutor, az as getUploadExecutor, aA as getVersionData, B as isItemOwned, aB as isLocalUnsealedDraft, D as isPublishedSeedRef, aC as isSeedRowOwned, a8 as listRelationEasPropertyName, aD as localUnsealedDraftSql, aE as ownedPublisherSql, aF as ownedSeedsSql, aG as pickLatestMetadataRowPerProperty, aH as placeholderUidSql, aI as propertyMachine, aJ as publisherInAddressListSql, aK as publisherIsInOwnedSet, aL as setAdditionalSyncAddresses, aM as setGetPublisherForNewSeeds, aN as setPublishExecutor, aO as setRevokeExecutor, aP as setUploadExecutor } from './Item-Bf4kWKpH.js';
+export { a as applyPropertyAttestationUidsFromPublish, e as estimateDataUriByteLength, g as getAttesterForSeed, b as getMetadataAttestationUidsForSeedUid, c as getSeedPublishState, d as getUnpublishedRelatedItems, f as getVersionsForSeedUid, m as markPropertyAttestationsRetracted, r as renameModelProperty, h as resolveMediaRef, s as summarizePublishWork, u as updateModelProperties, i as updateVersionUid } from './index-DmTtj1nk.js';
+export { S as Schema, s as schemaMachine } from './Schema-J_1f6p0c.js';
 export { D as DatabaseNotPersistentError, F as FileSystemLockedError } from './errors-C1qUEZ7A.js';
-export { M as MODEL_AMBIGUOUS_EVENT } from './resolveModelForSyncedSeed-4gO9Hfn2.js';
-export { ModelProperty } from './ModelProperty-i5flwzQG.js';
-export { getModelSchemasFromEas } from './eas-dyepi5jz.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, hasArweaveContentReadTransform, invalidateReadGatewayCache, invalidateSidecarProbeCache, isArweaveL1AnchoringComplete, isEasAttestationExplorerUrl, isGatewayHostCircuitOpen, isKnownArweaveGatewayHostname, isReadGatewayKnownHealthy, mergePrimaryHostWithDefaults, normalizeGatewayHostKey, normalizeUploadApiBaseUrl, queryArweaveGatewayTransaction, queryArweaveGatewayTransactionWithFallback, readArweaveContentResponse, recordGatewayHostFailure, recordGatewayHostSuccess, resetArweaveReadGatewayForTests, resolveSeedGatewayEndpoints, resolveSeedRssImageRelationFromItem, resolveSeedRssImageRelationRef, seedGatewayConfigFromClientContext, seedGatewayConfigFromSeedConfig, setArweaveContentReadTransform, setPreferredArweaveReadBaseUrls, setResolvedSeedGatewayEndpoints, transformArweaveContent } from '@seedprotocol/arweave';
-export { u as updateSeedRevokedAt } from './updateSeedRevokedAt-CP606vKs.js';
-import { I as ItemLoads, a as getSegmentedItemProperties, w as withItemLoads, g as getPublishDraftGraph, i as isSeedRevoked, f as findRelatedSeedRow, b as isUnpublishedSeed, h as htmlPropertyNameForHtmlSeed, r as relatedModelNameFromDef } from './publishDraftGraph-C5F6b7GK.js';
-export { P as PublishValidationFailedError, R as RELATED_ITEM_UNPUBLISHED_CODE, a as RelatedItemUnpublishedError, r as resolvePublishPayloadValues, v as validateItemForPublish } from './getPublishPayload-DH4rMqXG.js';
-import 'pluralize';
-import { g as getRelatedDraftsCoPublishedWith, f as findEmbeddedImageFilePath } from './getPublishUploads-BzUIDA2G.js';
-export { H as HTML_EMBEDDED_MAX_IMAGES_PER_DOC, a as HTML_EMBEDDED_MAX_IMAGE_BYTES, b as HTML_EMBEDDED_MAX_TOTAL_BYTES, c as HtmlEmbeddedDataUriLimitError, d as HtmlSeedPropertyRefError, S as SEED_PROPERTY_REF_PREFIX, e as clearHtmlEmbeddedImageCoPublishRows, h as extractDataUriImagesFromHtml, i as findSeedPropertyRefsInHtml, j as getPublishUploadData, k as itemHasPublishUploadCandidates, p as prepareHtmlEmbeddedImagesForPublish, r as replaceDataUrisInParsedHtml, l as replaceSeedPropertyRefsInHtml, m as resolveEffectiveHtmlEmbeddedDataUriPolicy, n as rewriteHtmlEmbeddedImagesOnDisk } from './getPublishUploads-BzUIDA2G.js';
+export { M as MODEL_AMBIGUOUS_EVENT, u as updateSeedRevokedAt } from './updateSeedRevokedAt-BL9Bg-G7.js';
+export { ModelProperty } from './ModelProperty-BlaEgb_U.js';
+export { EAS_CHAIN_DEPLOYMENTS, BaseEasClient as EasClient, VERSION_SCHEMA_DEF, VERSION_SCHEMA_UID, easName, getCanonicalItemPropertiesFromEas, getEasChainDeployment, getEasEndpoint, getEasReadChainId, getEasSchemaUidForExactDefinition, getItemPropertiesFromEas, getItemVersionsFromEas, getSeedsBySchemaName, getSeedsFromSchemaUids, isPlaceholderUid, isValidEasAttestationUid, matchEasName, normalizeBytes32Hex, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForModel, setSchemaUidForSchemaDefinition, withExcludeRevokedFilter } from '@seedprotocol/eas';
+export { getModelSchemasFromEas } from './eas-wB_fQ8Tc.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, classifyMediaRef, ensureReadGatewaySelected, fetchArweaveRawFromBaseUrl, fetchArweaveRawTextAcrossGateways, getArweaveReadBaseUrls, getArweaveUploadStatus, getDefaultArweaveReadGatewayHostsOrdered, getFeedItemStringField, getLastHealthyReadGatewayHost, getPreferredArweaveReadBaseUrls, getReadGatewayHostsForConfig, getResolvedArweaveReadBaseUrls, getResolvedSeedGatewayEndpoints, getUploadApiArweaveDataUrl, getUploadApiArweaveStatusUrl, getUploadPipelineTransactionStatus, hasArweaveContentReadTransform, invalidateReadGatewayCache, invalidateSidecarProbeCache, isArweaveL1AnchoringComplete, isEasAttestationExplorerUrl, isGatewayHostCircuitOpen, isKnownArweaveGatewayHostname, isReadGatewayKnownHealthy, mergePrimaryHostWithDefaults, normalizeFeedItemFields, normalizeGatewayHostKey, normalizeRelationPropertyValue, normalizeUploadApiBaseUrl, queryArweaveGatewayTransaction, queryArweaveGatewayTransactionWithFallback, readArweaveContentResponse, recordGatewayHostFailure, recordGatewayHostSuccess, resetArweaveReadGatewayForTests, resolveSeedGatewayEndpoints, resolveSeedIdsFromRefString, resolveSeedRssImageRelationFromItem, resolveSeedRssImageRelationRef, seedGatewayConfigFromClientContext, seedGatewayConfigFromSeedConfig, setArweaveContentReadTransform, setPreferredArweaveReadBaseUrls, setResolvedSeedGatewayEndpoints, transformArweaveContent } from '@seedprotocol/arweave';
+export { getPublishPendingDiff } from './getPublishPendingDiff-D6_-A5ns.js';
+export { P as PublishValidationFailedError, R as RELATED_ITEM_UNPUBLISHED_CODE, a as RelatedItemUnpublishedError, b as getPendingRetractions, r as resolvePublishPayloadValues, v as validateItemForPublish } from './getPublishPayload-BnIwpwz1.js';
+export { g as getPublishGraph } from './publishGraph-EcB40Uii.js';
+export { H as HTML_EMBEDDED_MAX_IMAGES_PER_DOC, a as HTML_EMBEDDED_MAX_IMAGE_BYTES, b as HTML_EMBEDDED_MAX_TOTAL_BYTES, c as HtmlEmbeddedDataUriLimitError, d as HtmlSeedPropertyRefError, S as SEED_PROPERTY_REF_PREFIX, e as clearHtmlEmbeddedImageCoPublishRows, f as extractDataUriImagesFromHtml, h as findSeedPropertyRefsInHtml, i as getPublishUploadData, j as itemHasPublishUploadCandidates, p as prepareHtmlEmbeddedImagesForPublish, r as replaceDataUrisInParsedHtml, k as replaceSeedPropertyRefsInHtml, l as resolveEffectiveHtmlEmbeddedDataUriPolicy, m as rewriteHtmlEmbeddedImagesOnDisk } from './getPublishUploads-sS6JfPgz.js';
 import 'xstate';
 import 'debug';
-import './model-oHA3YhOd.js';
+import 'pluralize';
+import 'drizzle-orm';
 import '@sinclair/typebox';
+import 'lodash-es';
+import '@noble/hashes/sha3';
+import '@noble/hashes/utils';
+import '@seedprotocol/query';
 import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
-import '@noble/hashes/sha3';
-import '@noble/hashes/utils';
-import 'lodash-es';
-import '@seedprotocol/query';
 import 'rxjs';
-import './SchemaValidationService-DnGKel4V.js';
+import './SchemaValidationService-CnmKyzR-.js';
 import '@sinclair/typebox/value';
-import './findSeedRowsByUid-CT3sOXXw.js';
 import 'parse5';
-import './mimeTypes-C9r76DCH.js';
-
-/**
- * Updates the version record with the attestation UID after a Version attestation is created.
- * Targets the first version without a uid yet in head-version order (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, }) => {
-    if (!seedLocalId || !versionUid) {
-        return;
-    }
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return;
-    const rows = await appDb
-        .select({ localId: versions.localId, uid: versions.uid, publisher: versions.publisher })
-        .from(versions)
-        .where(eq(versions.seedLocalId, seedLocalId))
-        .orderBy(latestVersionOrder());
-    // 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;
-        await appDb.insert(versions).values({
-            localId: generateId(),
-            seedLocalId,
-            seedType: seed.type,
-            uid: versionUid,
-            ...(normalizedPublisher && { publisher: normalizedPublisher }),
-            ...(attestationCreatedAt != null && { attestationCreatedAt }),
-        });
-        return;
-    }
-    let shouldSetPublisher = normalizedPublisher != null;
-    if (shouldSetPublisher && toUpdate.publisher != null && toUpdate.publisher !== '') {
-        shouldSetPublisher = false;
-    }
-    await appDb
-        .update(versions)
-        .set({
-        uid: versionUid,
-        ...(shouldSetPublisher && { publisher: normalizedPublisher }),
-        ...(attestationCreatedAt != null && { attestationCreatedAt }),
-    })
-        .where(eq(versions.localId, toUpdate.localId));
-};
-
-/**
- * After property attestations succeed, write EAS UIDs onto the latest placeholder metadata row
- * 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.
- *
- * Relations and lists of relations are recorded as attested, the way an EAS sync of the
- * attestation stores them:
- * - a List of Relation row lives under its storage name (`authors` → `authorIdentityIds`) while a
- *   publish names the attestation by schema key; either name matches.
- * - a value naming seeds by local id gets the seed uids the attestation encodes: the uid (Relation),
- *   a JSON array of uids in slot order (List). Each uid comes from `resolvedSeedUids` (seeds this
- *   publish created, not recorded on their seed rows yet), else the seed's recorded live uid.
- */
-async function applyPropertyAttestationUidsFromPublish(params) {
-    const { seedLocalId, attestationCreatedAtMs, pairs, versionUid, resolvedSeedUids } = 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;
-    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);
-    }
-    const refDefs = await loadRefPropertyDefs(appDb, seedLocalId, rows);
-    const attestedRefValue = async (row, def) => {
-        const d = def ?? (row.propertyName ? refDefs.get(row.propertyName) : undefined);
-        if (!d || row.propertyValue == null)
-            return undefined;
-        return toAttestedRefValue(appDb, row.propertyValue, d.kind, resolvedSeedUids ?? {});
-    };
-    for (const pair of pairs) {
-        const att = pair.attestationUid?.trim();
-        if (!isValidEasAttestationUid(att))
-            continue;
-        const wantSchema = normalizeBytes32Hex(pair.schemaUid);
-        if (!wantSchema)
-            continue;
-        const pairName = pair.propertyName != null && pair.propertyName !== '' ? pair.propertyName : undefined;
-        const pairDef = pairName ? refDefs.get(pairName) : undefined;
-        const pairNames = new Set(pairName ? [pairName, ...(pairDef ? [pairDef.schemaKey, pairDef.storageName] : [])] : []);
-        const attestedRow = pair.metadataLocalId
-            ? working.find((r) => r.localId === pair.metadataLocalId)
-            : undefined;
-        const candidates = attestedRow
-            ? [attestedRow]
-            : 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 || !pairNames.has(r.propertyName))
-                        return false;
-                    if (r.schemaUid) {
-                        return normalizeBytes32Hex(r.schemaUid) === wantSchema;
-                    }
-                    return true;
-                }
-                if (!r.schemaUid)
-                    return false;
-                return normalizeBytes32Hex(r.schemaUid) === wantSchema;
-            })
-                .sort(compareMetadataRowsLatestFirst);
-        const target = candidates.find((r) => isPlaceholderUid(r.uid));
-        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 attestedValue = await attestedRefValue(source, pairDef);
-            const row = {
-                ...source,
-                ...(attestedValue !== undefined && { propertyValue: attestedValue }),
-                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,
-                // Stamped here: the spread copies the source row's times.
-                createdAt: now,
-                updatedAt: now,
-            };
-            await appDb.insert(metadata).values(row);
-            working.push(row);
-            continue;
-        }
-        const writeSchemaUid = !normalizeBytes32Hex(target.schemaUid);
-        const attestedValue = await attestedRefValue(target, pairDef);
-        await appDb
-            .update(metadata)
-            .set({
-            uid: att,
-            ...(attestedValue !== undefined && { propertyValue: attestedValue }),
-            ...(writeSchemaUid && { schemaUid: wantSchema }),
-            ...(attestationCreatedAtMs != null && { attestationCreatedAt: attestationCreatedAtMs }),
-            ...(validVersion && { versionUid: validVersion }),
-            ...(versionLocalId && { versionLocalId }),
-        })
-            .where(eq(metadata.localId, target.localId));
-        const i = working.findIndex((r) => r.localId === target.localId);
-        if (i >= 0) {
-            working[i] = {
-                ...working[i],
-                uid: att,
-                ...(attestedValue !== undefined && { propertyValue: attestedValue }),
-                ...(writeSchemaUid && { schemaUid: wantSchema }),
-                attestationCreatedAt: attestationCreatedAtMs ?? working[i].attestationCreatedAt,
-                ...(validVersion && { versionUid: validVersion }),
-                ...(versionLocalId && { versionLocalId }),
-            };
-        }
-    }
-}
-/**
- * The seed's Relation and List-of-Relation properties, keyed by schema key and (lists) by storage
- * name. The model comes from the seed's model_file_id, else a metadata row's property_id; an
- * unknown model gives no definitions (rows then match by the pair's name alone, values unchanged).
- */
-async function loadRefPropertyDefs(appDb, seedLocalId, rows) {
-    const out = new Map();
-    try {
-        let modelId;
-        const [seedRow] = await appDb
-            .select({ modelFileId: seeds.modelFileId })
-            .from(seeds)
-            .where(eq(seeds.localId, seedLocalId))
-            .limit(1);
-        if (seedRow?.modelFileId) {
-            const [m] = await appDb
-                .select({ id: models.id })
-                .from(models)
-                .where(eq(models.schemaFileId, seedRow.modelFileId))
-                .limit(1);
-            modelId = m?.id;
-        }
-        const propertyId = rows.find((r) => r.propertyId != null)?.propertyId;
-        if (modelId == null && propertyId != null) {
-            const [p] = await appDb
-                .select({ modelId: properties.modelId })
-                .from(properties)
-                .where(eq(properties.id, propertyId))
-                .limit(1);
-            modelId = p?.modelId ?? undefined;
-        }
-        if (modelId == null)
-            return out;
-        const props = await appDb
-            .select({
-            name: properties.name,
-            dataType: properties.dataType,
-            refModelId: properties.refModelId,
-            refValueType: properties.refValueType,
-        })
-            .from(properties)
-            .where(eq(properties.modelId, modelId));
-        const refIds = [...new Set(props.map((p) => p.refModelId).filter((id) => id != null))];
-        const refNames = new Map();
-        if (refIds.length) {
-            const refs = await appDb
-                .select({ id: models.id, name: models.name })
-                .from(models)
-                .where(inArray(models.id, refIds));
-            for (const r of refs)
-                refNames.set(r.id, r.name);
-        }
-        for (const p of props) {
-            const dataType = normalizeDataType(p.dataType);
-            if (dataType === 'Relation') {
-                out.set(p.name, { kind: 'relation', schemaKey: p.name, storageName: p.name });
-                continue;
-            }
-            if (dataType !== 'List' || normalizeDataType(p.refValueType ?? undefined) !== 'Relation')
-                continue;
-            const ref = p.refModelId != null ? refNames.get(p.refModelId) : undefined;
-            const storageName = ref ? listRelationEasPropertyName(p.name, { dataType: 'List', ref }) : undefined;
-            if (!storageName)
-                continue;
-            const def = { kind: 'list', schemaKey: p.name, storageName };
-            out.set(p.name, def);
-            out.set(storageName, def);
-        }
-    }
-    catch {
-        // Unknown model: match by the pair's name alone.
-    }
-    return out;
-}
-const isUid = (v) => /^0x[0-9a-fA-F]{64}$/.test(v);
-/**
- * `raw` (a Relation value, or a List value as stored) with every seed named by local id replaced by
- * its uid: from `resolvedSeedUids`, else the seed's recorded live uid. Undefined when nothing
- * changes, or when a seed has no uid (then the value is not what was attested; left as it is).
- */
-async function toAttestedRefValue(appDb, raw, kind, resolvedSeedUids) {
-    const refs = kind === 'list' ? parseListPropertyValueFromStorage(raw) : [raw.trim()];
-    if (refs.length === 0 || refs.some((r) => !r))
-        return undefined;
-    const unknown = [...new Set(refs.filter((r) => !isUid(r) && !resolvedSeedUids[r]))];
-    const recorded = new Map();
-    if (unknown.length) {
-        const seedRows = await appDb
-            .select({ localId: seeds.localId, uid: seeds.uid, revokedAt: seeds.revokedAt })
-            .from(seeds)
-            .where(inArray(seeds.localId, unknown));
-        for (const s of seedRows) {
-            if (s.localId && isValidEasAttestationUid(s.uid) && !isVersionRevoked(s.revokedAt)) {
-                recorded.set(s.localId, s.uid);
-            }
-        }
-    }
-    const out = [];
-    for (const ref of refs) {
-        const uid = isUid(ref) ? ref : (resolvedSeedUids[ref] ?? recorded.get(ref));
-        if (!uid)
-            return undefined;
-        out.push(uid);
-    }
-    const value = kind === 'list' ? JSON.stringify(out) : out[0];
-    return value === raw ? undefined : value;
-}
-
-const getEasSchemaForItemProperty = async ({ schemaUid, propertyName, easDataType, }) => {
-    try {
-        const propertyNameSnakeCase = easName(propertyName);
-        const isMissingSchemaUid = !schemaUid || schemaUid === 'null' || schemaUid === 'undefined';
-        const queryClient = BaseQueryClient.getQueryClient();
-        const easClient = BaseEasClient.getEasClient();
-        // If clients are not available, return undefined (schema not found)
-        if (!queryClient || !easClient) {
-            return;
-        }
-        let queryParams = {
-            where: {
-                id: {
-                    equals: schemaUid,
-                },
-            },
-        };
-        if (easDataType) {
-            queryParams = {
-                where: {
-                    schema: {
-                        equals: `${easDataType} ${propertyNameSnakeCase}`,
-                    },
-                },
-            };
-        }
-        if (!easDataType && isMissingSchemaUid) {
-            queryParams = {
-                where: {
-                    schemaNames: {
-                        some: {
-                            name: {
-                                equals: propertyNameSnakeCase,
-                            },
-                        },
-                    },
-                },
-            };
-        }
-        const foundPropertySchema = await queryClient.fetchQuery({
-            queryKey: [`getEasSchemaForItemProperty`, queryParams],
-            queryFn: async () => easClient.request(GET_SCHEMAS, queryParams),
-            networkMode: 'offlineFirst',
-        });
-        if (foundPropertySchema && foundPropertySchema.schemas.length > 0) {
-            return foundPropertySchema.schemas[0];
-        }
-    }
-    catch (error) {
-        // If schema fetch fails, return undefined (schema not found)
-        // This is expected when metadata exists without a published EASSchema
-        if (process.env.NODE_ENV === 'development') {
-            console.warn(`Failed to fetch schema for property ${propertyName}:`, error);
-        }
-        return;
-    }
-};
-
-const getVersionsForSeedUid = async (seedUid) => {
-    if (!seedUid)
-        return [];
-    const appDb = BaseDb.getAppDb();
-    const rows = (await appDb
-        .select({ uid: versions.uid, seedUid: versions.seedUid })
-        .from(versions)
-        .where(eq(versions.seedUid, seedUid)));
-    return rows
-        .filter((r) => r.uid && r.uid !== '0x' + '0'.repeat(64))
-        .map((r) => ({ uid: r.uid }));
-};
-
-function resolveSeedIds$1(arg) {
-    if (arg && typeof arg === 'object' && 'seedLocalId' in arg) {
-        const item = arg;
-        return {
-            seedLocalId: item.seedLocalId,
-            seedUid: item.seedUid,
-        };
-    }
-    return arg;
-}
-/**
- * Per property: the **latest** metadata row (by `attestationCreatedAt` / `createdAt`) lacks a valid
- * 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) {
-    const { seedLocalId, seedUid } = resolveSeedIds$1(arg);
-    const appDb = BaseDb.getAppDb();
-    const empty = {
-        pendingProperties: [],
-        lastPublishedVersionUid: null,
-        lastVersionPublishedAt: null,
-    };
-    if (!appDb || (!seedLocalId && !seedUid)) {
-        return empty;
-    }
-    const whereClause = seedLocalId && seedUid
-        ? or(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid))
-        : seedLocalId
-            ? eq(metadata.seedLocalId, seedLocalId)
-            : eq(metadata.seedUid, seedUid);
-    const rows = (await appDb.select().from(metadata).where(whereClause));
-    const byProp = new Map();
-    for (const row of rows) {
-        const name = row.propertyName ?? '';
-        if (!name)
-            continue;
-        const list = byProp.get(name) ?? [];
-        list.push(row);
-        byProp.set(name, list);
-    }
-    for (const list of byProp.values()) {
-        list.sort(compareMetadataRowsLatestFirst);
-    }
-    const pendingProperties = [];
-    for (const [propertyName, list] of byProp) {
-        const latest = list[0];
-        if (!latest)
-            continue;
-        if (!isPublishedMetadataRow(latest)) {
-            const prevWithUid = list.find(isPublishedMetadataRow);
-            pendingProperties.push({
-                propertyName,
-                currentValue: latest.propertyValue ?? null,
-                previousPublishedValue: prevWithUid?.propertyValue ?? null,
-                pending: true,
-            });
-        }
-    }
-    pendingProperties.sort((a, b) => a.propertyName.localeCompare(b.propertyName));
-    let lastPublishedVersionUid = null;
-    let lastVersionPublishedAt = null;
-    if (seedLocalId) {
-        const published = await getLatestPublishedVersionRow(seedLocalId);
-        if (published) {
-            lastPublishedVersionUid = published.uid;
-            if (published.attestationCreatedAt != null) {
-                lastVersionPublishedAt = published.attestationCreatedAt;
-            }
-        }
-    }
-    return {
-        pendingProperties,
-        lastPublishedVersionUid,
-        lastVersionPublishedAt,
-    };
-}
-
-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`, 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) {
-    const { seedLocalId, seedUid } = resolveSeedIds(arg);
-    const appDb = BaseDb.getAppDb();
-    const empty = {
-        status: 'draft',
-        seedAttestationUid: null,
-        versionAttestationUid: null,
-        explorerUid: null,
-        lastAttestedAtMs: null,
-        revokedAt: 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,
-        revokedAt: seedRow?.revokedAt ? seedRow.revokedAt : null,
-    };
-}
-
-/**
- * Returns attestation UIDs (metadata.uid) for all metadata records belonging to a seed.
- * Used when revoking attestations - metadata attestations must be revoked.
- */
-const getMetadataAttestationUidsForSeedUid = async (seedUid) => {
-    if (!seedUid)
-        return [];
-    const appDb = BaseDb.getAppDb();
-    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, '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 }));
-};
-
-function getAttesterFromRow(row) {
-    if (row.publisher)
-        return row.publisher;
-    if (row.attestationRaw) {
-        try {
-            const parsed = JSON.parse(row.attestationRaw);
-            return parsed.attester ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Returns the attester address for a seed (from seeds.publisher or attestationRaw.attester).
- * Used when revoking attestations to determine which account must perform the revoke.
- *
- * @param seedLocalId - Optional seed local ID
- * @param seedUid - Optional seed UID (attestation ID)
- * @returns The attester address, or null if not found or no attester
- */
-async function getAttesterForSeed(params) {
-    const { seedLocalId, seedUid } = params;
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return null;
-    const conditions = [];
-    if (seedLocalId)
-        conditions.push(eq(seeds.localId, seedLocalId));
-    if (seedUid)
-        conditions.push(eq(seeds.uid, seedUid));
-    if (conditions.length === 0)
-        return null;
-    const seedRows = await appDb
-        .select({
-        publisher: seeds.publisher,
-        attestationRaw: seeds.attestationRaw,
-    })
-        .from(seeds)
-        .where(conditions.length === 1 ? conditions[0] : or(...conditions))
-        .limit(1);
-    if (!seedRows || seedRows.length === 0)
-        return null;
-    return getAttesterFromRow(seedRows[0]);
-}
-
-/**
- * Collects all items that will be in the publish payload (main item + related items from
- * relations and lists). Used by ensureEasSchemas to register schemas for nested items.
- * Skips items that already have seedUid (already published).
- *
- * Each returned item carries one cache hold the caller releases with `unload()`.
- */
-async function getRelatedItemsForPublish(item, visited = new Set()) {
-    const loads = new ItemLoads();
-    let result = [];
-    try {
-        result = await collectRelatedItemsForPublish(item, visited, loads);
-    }
-    finally {
-        loads.release(result);
-    }
-    return result;
-}
-async function collectRelatedItemsForPublish(item, visited, loads) {
-    const seedLocalId = item.seedLocalId;
-    if (!seedLocalId || visited.has(seedLocalId)) {
-        return [];
-    }
-    visited.add(seedLocalId);
-    const result = [];
-    const { itemRelationProperties, itemImageProperties, itemListProperties } = await getSegmentedItemProperties(item);
-    const processRelationOrImage = async (prop) => {
-        const snapshot = prop.getService().getSnapshot();
-        const context = snapshot.context ?? null;
-        if (!context)
-            return;
-        let value = context.propertyValue;
-        // File/Image/Html/Json: fallback to metadata when propertyValue is empty (e.g. schema-loaded before metadata)
-        const isStorageSeedType = (t) => isDataType(t, ModelPropertyDataTypes.File) ||
-            isDataType(t, ModelPropertyDataTypes.Image) ||
-            isDataType(t, ModelPropertyDataTypes.Html) ||
-            isDataType(t, ModelPropertyDataTypes.Json);
-        const isStorageSeed = isStorageSeedType(prop.propertyDef?.dataType) ||
-            (isDataType(prop.propertyDef?.dataType, ModelPropertyDataTypes.Relation) &&
-                isStorageSeedType(prop.propertyDef?.refValueType));
-        if (!value && prop.propertyName && isStorageSeed) {
-            const ctx = context;
-            if (ctx.seedLocalId || ctx.seedUid) {
-                const _mod_0 = await import('./Item-0oDoTPhi.js');
-                const _ns_0 = _mod_0.at;
-                const { getPropertyData } = _ns_0;
-                const meta = await getPropertyData({
-                    propertyName: prop.propertyName,
-                    seedLocalId: ctx.seedLocalId,
-                    seedUid: ctx.seedUid,
-                });
-                value = meta?.propertyValue;
-            }
-        }
-        const normalized = normalizeRelationPropertyValue(value);
-        if (!normalized)
-            return;
-        const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalized);
-        if (!seedLocalId && !seedUid)
-            return;
-        const relatedItem = await loads.getItem({ seedLocalId, seedUid });
-        if (!relatedItem || relatedItem.seedUid)
-            return;
-        const nested = await collectRelatedItemsForPublish(relatedItem, visited, loads);
-        result.push(...nested, relatedItem);
-    };
-    for (const prop of [...itemRelationProperties, ...itemImageProperties]) {
-        await processRelationOrImage(prop);
-    }
-    for (const listProperty of itemListProperties) {
-        const listRef = listProperty.propertyDef?.ref ||
-            listProperty.propertyDef?.refModelName;
-        if (!listRef)
-            continue;
-        const snapshot = listProperty.getService().getSnapshot();
-        const context = snapshot.context ?? null;
-        if (!context)
-            continue;
-        let value = context.propertyValue;
-        if (!value || listProperty.uid)
-            continue;
-        if (typeof value === 'string') {
-            value = parseListPropertyValueFromStorage(value);
-        }
-        const arr = Array.isArray(value) ? value : [];
-        for (const seedId of arr) {
-            const normalized = normalizeRelationPropertyValue(seedId);
-            if (!normalized)
-                continue;
-            const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalized);
-            if (!seedLocalId && !seedUid)
-                continue;
-            const relatedItem = await loads.getItem({ seedLocalId, seedUid });
-            if (!relatedItem || relatedItem.seedUid)
-                continue;
-            const nested = await collectRelatedItemsForPublish(relatedItem, visited, loads);
-            result.push(...nested, relatedItem);
-        }
-    }
-    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;
-}
-function isStorageTransactionPropertyName(name) {
-    return name === 'storageTransactionId' || name === 'storage_transaction_id';
-}
-/** 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 propertyContext(prop) {
-    const snapshot = prop.getService().getSnapshot();
-    return snapshot && 'context' in snapshot
-        ? (snapshot.context ?? null)
-        : null;
-}
-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;
-            }
-        }
-    }
-    return value;
-}
-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 addUpload(acc, seen, key, bytes) {
-    if (bytes <= 0 || seen.has(key))
-        return;
-    seen.add(key);
-    acc.uploadCount += 1;
-    acc.uploadBytes += bytes;
-    acc.uploadSizes.push(bytes);
-}
-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);
-}
-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}`);
-    }
-}
-async function loadRelatedItem(value, loads) {
-    const normalized = normalizeRelationPropertyValue(value);
-    if (!normalized)
-        return undefined;
-    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(normalized);
-    if (!seedLocalId && !seedUid)
-        return undefined;
-    try {
-        return await loads.getItem({ seedLocalId, seedUid });
-    }
-    catch {
-        return undefined;
-    }
-}
-async function relatedIfUnpublished(prop, loads) {
-    const context = propertyContext(prop);
-    if (!context)
-        return undefined;
-    const related = await loadRelatedItem(context.propertyValue, loads);
-    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, loads, backReferences) {
-    for (const prop of props) {
-        if (!shouldAttestProperty(prop, forceFullSnapshot))
-            continue;
-        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;
-            }
-            const related = await loadRelatedItem(row.seedLocalId, loads);
-            out.push({
-                propertyName: prop.propertyName,
-                modelName: related?.modelName ?? relatedModelNameFromDef(prop.propertyDef) ?? row.type ?? 'unknown',
-                seedLocalId: row.seedLocalId,
-                seedUid: row.seedUid,
-            });
-        }
-    }
-}
-/**
- * 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 collectUnpublishedEmbeddedImages(item, out, loads) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb || !item.seedLocalId)
-        return;
-    for (const owner of [item, ...(await getRelatedDraftsCoPublishedWith(item, loads))]) {
-        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, loads) {
-    const appDb = BaseDb.getAppDb();
-    if (!appDb)
-        return;
-    const rows = await appDb
-        .select()
-        .from(htmlEmbeddedImageCoPublish)
-        .where(eq(htmlEmbeddedImageCoPublish.parentSeedLocalId, item.seedLocalId));
-    for (const row of rows) {
-        const imageItem = await loads.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 filePath = await findEmbeddedImageFilePath(imageItem.seedLocalId);
-        if (filePath)
-            await addUploadFromPath(acc, seen, filePath, `seed:${imageItem.seedLocalId}`);
-        await summarizeItem(imageItem, publishMode, forceFullSnapshot, acc, seen, visited, graph, loads);
-    }
-}
-async function summarizeItem(item, publishMode, forceFullSnapshot, acc, seenUploads, visited, graph, loads) {
-    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, loads, graph.backReferences);
-    await collectUnpublishedRelatedItems(itemListProperties, true, forceFullSnapshot, acc.unpublishedRelatedItems, loads, 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, loads);
-        if (related) {
-            await summarizeItem(related, publishMode, forceFullSnapshot, acc, seenUploads, visited, graph, loads);
-        }
-    }
-    await appendCoPublishImages(item, acc, seenUploads, visited, forceFullSnapshot, publishMode, graph, loads);
-    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;
-        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;
-        if (shouldAttestProperty(prop, forceFullSnapshot))
-            acc.attestationCount += 1;
-    }
-}
-/**
- * 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.
- */
-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, loads) {
-    const { itemRelationProperties, itemListProperties, itemImageProperties } = await getSegmentedItemProperties(item);
-    await collectUnpublishedRelatedItems([...itemRelationProperties, ...itemImageProperties], false, forceFullSnapshot, out, loads, backReferences);
-    await collectUnpublishedRelatedItems(itemListProperties, true, forceFullSnapshot, out, loads, 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 = [];
-    await withItemLoads(undefined, async (loads) => {
-        // The item and every draft its publish carries along (publishDraftGraph.ts).
-        const { drafts, backReferences } = await getPublishDraftGraph(item, { forceFullSnapshot, loads });
-        for (const owner of [item, ...drafts.map((d) => d.item)]) {
-            await collectUnpublishedRelatedItemsOf(owner, forceFullSnapshot, out, backReferences, loads);
-        }
-        await collectUnpublishedEmbeddedImages(item, out, loads);
-    });
-    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,
-        uploadSizes: [],
-        unpublishedRelatedItems: [],
-    };
-    await withItemLoads(undefined, async (loads) => {
-        const graph = await getPublishDraftGraph(item, { forceFullSnapshot, loads });
-        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, loads);
-        }
-        await collectUnpublishedEmbeddedImages(item, acc.unpublishedRelatedItems, loads);
-    });
-    // 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, ModelPropertyDataTypes, applyPropertyAttestationUidsFromPublish, compareMetadataRowsLatestFirst, estimateDataUriByteLength, generateId, getAttesterForSeed, getEasSchemaForItemProperty, getMetadataAttestationUidsForSeedUid, getPublishDraftGraph, getPublishPendingDiff, getRelatedItemsForPublish, getSeedPublishState, getSegmentedItemProperties, getUnpublishedRelatedItems, getVersionsForSeedUid, htmlEmbeddedImageCoPublish, isDataType, listRelationEasPropertyName, metadata, models, normalizeDataType, normalizePublisher, normalizeRelationPropertyValue, properties, resolveSeedIdsFromRefString, seeds, shouldAttestProperty, summarizePublishWork, updateVersionUid, versions };
 //# sourceMappingURL=main.js.map