@seedprotocol/sdk 0.7.9-next.1189.g5e63267 → 0.7.9

package/dist/index-DmTtj1nk.js

@@ -0,0 +1,817 @@
+import { w as writeNextSchemaVersion, o as applySchemaFile } from './errors-DLSoqSHG.js';
+import { a7 as convertTxIdToImage, x as normalizePublisher, m as generateId, n as normalizeDataType, j as findSeedRow, w as writeInBatches, a0 as INTERNAL_PROPERTY_NAMES, i as isDataType, M as ModelPropertyDataTypes, r as resolveModelRecord } from './tabEvents-CaVmngqr.js';
+import './property-BxUYznH0.js';
+import { B as BaseDb, v as versions, s as seeds, m as metadata, d as models, l as properties, w as BaseFileManager } from './BaseFileManager-BAlySv8w.js';
+import { am as getStorageTransactionIdForSeedUid, an as latestVersionOrder, ao as otherVersionRowsWithUid, ap as mergeVersionRowInto, M as isVersionRevoked, aq as findMetadataPropertyByName, N as readModelMetadataProperties, S as parseListPropertyValueFromStorage, L as getLatestPublishedVersionRow, ar as resolvePublisherFromSeedRow } from './Item-Bf4kWKpH.js';
+import { eq, and, inArray, or, isNull } from 'drizzle-orm';
+import { classifyMediaRef, BaseArweaveClient } from '@seedprotocol/arweave';
+import 'pluralize';
+import { isPlaceholderUid, isValidEasAttestationUid, normalizeBytes32Hex } from '@seedprotocol/eas';
+import './Schema-J_1f6p0c.js';
+import './errors-C1qUEZ7A.js';
+import './updateSeedRevokedAt-BL9Bg-G7.js';
+import './ModelProperty-BlaEgb_U.js';
+import './eas-wB_fQ8Tc.js';
+import './getPublishPendingDiff-D6_-A5ns.js';
+import { g as getPropertyClear } from './getPublishPayload-BnIwpwz1.js';
+import { g as getPublishGraph } from './publishGraph-EcB40Uii.js';
+import { g as getPublishUploadSources } from './getPublishUploads-sS6JfPgz.js';
+import debug from 'debug';
+
+/** Classification and feed-field helpers live in `@seedprotocol/arweave`; resolving needs the local DB and files. */
+async function resolveTxId(txId) {
+    const local = await convertTxIdToImage(txId);
+    if (local) {
+        return { status: 'ready', href: local, source: 'localBlob' };
+    }
+    return {
+        status: 'ready',
+        href: BaseArweaveClient.getRawUrl(txId),
+        source: 'gateway',
+    };
+}
+/**
+ * Resolve a classified media reference to a display URL (https/blob/data), using local files when present.
+ * A `localBlob` result's href is a new blob: URL per call: the caller revokes it
+ * (`URL.revokeObjectURL`) when it stops displaying it, as `useResolvedMediaRef` does.
+ */
+async function resolveMediaRef(raw, options) {
+    const classification = classifyMediaRef(raw, options);
+    switch (classification.kind) {
+        case 'empty':
+            return { status: 'empty' };
+        case 'url':
+            return {
+                status: 'ready',
+                href: classification.href,
+                source: 'direct',
+            };
+        case 'nonMediaUrl':
+            return {
+                status: 'unresolved',
+                reason: 'non_media_url',
+                classification,
+            };
+        case 'seedLocalId':
+            return {
+                status: 'unresolved',
+                reason: 'seed_local_id_not_portable',
+                classification,
+            };
+        case 'unknown':
+            return {
+                status: 'unresolved',
+                reason: 'unknown_ref',
+                classification,
+            };
+        case 'arweaveTxId':
+            return resolveTxId(classification.txId);
+        case 'seedUid': {
+            const appDb = BaseDb.getAppDb();
+            if (!appDb) {
+                return {
+                    status: 'unresolved',
+                    reason: 'seed_uid_requires_app_db',
+                    classification,
+                };
+            }
+            const storageTransactionId = await getStorageTransactionIdForSeedUid(classification.uid);
+            if (!storageTransactionId) {
+                return {
+                    status: 'unresolved',
+                    reason: 'seed_uid_no_storage_transaction',
+                    classification,
+                };
+            }
+            return resolveTxId(storageTransactionId);
+        }
+        default:
+            return {
+                status: 'unresolved',
+                reason: 'unknown_ref',
+                classification,
+            };
+    }
+}
+
+/**
+ * Updates the version record with the attestation UID after a Version attestation is created, in
+ * one transaction. Targets `versionLocalId` when given, else 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. A version row
+ * another writer inserted for the same uid (a sync that ran during the publish) is merged into the
+ * target first, since versions.uid is unique.
+ * Publisher is immutable once set: we never overwrite an existing publisher.
+ */
+const updateVersionUid = async ({ seedLocalId, versionUid, versionLocalId, publisher, attestationCreatedAt, }) => {
+    if (!seedLocalId || !versionUid) {
+        return;
+    }
+    if (!BaseDb.getAppDb())
+        return;
+    const normalizedPublisher = normalizePublisher(publisher);
+    await BaseDb.transaction(async (tx) => {
+        const rows = await tx
+            .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) && (!versionLocalId || r.localId === versionLocalId));
+        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. A row
+            // another writer already stored for this uid stays (DO NOTHING).
+            const [seed] = await tx
+                .select({ type: seeds.type })
+                .from(seeds)
+                .where(eq(seeds.localId, seedLocalId))
+                .limit(1);
+            if (!seed)
+                return;
+            await tx
+                .insert(versions)
+                .values({
+                localId: generateId(),
+                seedLocalId,
+                seedType: seed.type,
+                uid: versionUid,
+                ...(normalizedPublisher && { publisher: normalizedPublisher }),
+                ...(attestationCreatedAt != null && { attestationCreatedAt }),
+            })
+                .onConflictDoNothing();
+            return;
+        }
+        for (const duplicate of await otherVersionRowsWithUid(tx, versionUid, toUpdate.localId)) {
+            await mergeVersionRowInto(tx, duplicate, toUpdate.localId);
+        }
+        const shouldSetPublisher = normalizedPublisher != null && (toUpdate.publisher == null || toUpdate.publisher === '');
+        await tx
+            .update(versions)
+            .set({
+            uid: versionUid,
+            ...(shouldSetPublisher && { publisher: normalizedPublisher }),
+            ...(attestationCreatedAt != null && { attestationCreatedAt }),
+        })
+            .where(eq(versions.localId, toUpdate.localId));
+    });
+};
+
+/**
+ * After property attestations succeed, records each one on the metadata row whose value it
+ * attested (`metadataLocalId`, which the payload read), so getPublishPendingDiff and later
+ * publishes stay aligned with on-chain state. No row is searched for by name: a newer row holds a
+ * value the chain doesn't have (audit 1.1, G18-4).
+ *
+ * - A placeholder row (no uid yet) takes the uid, the version, and the schema uid when it has none.
+ * - An attested row (a full-snapshot publish: `new_version`, or a republish after unpublish,
+ *   attests properties attested before) stays as it is, and the attestation is recorded as a new
+ *   row for the published version: a copy with the new uid, so readers show the published version
+ *   without a sync.
+ * - A pair with no row (a property with no row yet, e.g. a storage transaction slot) gets a new
+ *   row when it names its property and carries its value.
+ * 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 value naming seeds by local id gets the seed uids the attestation
+ * encodes, the uid (Relation) or 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));
+    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 props = await loadSeedProperties(appDb, seedLocalId, rows);
+    const propertyOfRow = (row) => (row.propertyId != null ? props.find((p) => p.id === row.propertyId) : undefined) ??
+        (row.propertyName ? findMetadataPropertyByName(props, row.propertyName) : undefined);
+    const attestedRefValue = async (row, property) => {
+        const kind = refKind(property);
+        if (!kind || row.propertyValue == null)
+            return undefined;
+        return toAttestedRefValue(appDb, row.propertyValue, kind, resolvedSeedUids ?? {});
+    };
+    for (const pair of pairs) {
+        const att = pair.attestationUid?.trim();
+        if (!isValidEasAttestationUid(att))
+            continue;
+        const wantSchema = normalizeBytes32Hex(pair.schemaUid);
+        if (!wantSchema)
+            continue;
+        // Already recorded (a replayed receipt)
+        if (working.some((r) => r.uid?.toLowerCase() === att.toLowerCase()))
+            continue;
+        const target = pair.metadataLocalId ? working.find((r) => r.localId === pair.metadataLocalId) : undefined;
+        const property = target ? propertyOfRow(target) : pair.propertyName ? findMetadataPropertyByName(props, pair.propertyName) : undefined;
+        const value = pair.value ?? target?.propertyValue ?? null;
+        const attestedValue = await attestedRefValue({ propertyValue: value }, property);
+        const recordedValue = attestedValue ?? value;
+        if (target?.localId && isPlaceholderUid(target.uid)) {
+            const update = {
+                uid: att,
+                ...(recordedValue !== target.propertyValue && { propertyValue: recordedValue }),
+                ...(!normalizeBytes32Hex(target.schemaUid) && { schemaUid: wantSchema }),
+                ...(attestationCreatedAtMs != null && { attestationCreatedAt: attestationCreatedAtMs }),
+                ...(validVersion && { versionUid: validVersion }),
+                ...(versionLocalId && { versionLocalId }),
+            };
+            await appDb.update(metadata).set(update).where(eq(metadata.localId, target.localId));
+            Object.assign(target, update);
+            continue;
+        }
+        // An attested row (full snapshot), or none: record the attestation as a new row for the
+        // published version.
+        if (!validVersion)
+            continue;
+        if (!target && (!pair.propertyName || pair.value == null))
+            continue;
+        const now = Date.now();
+        const row = {
+            ...(target ?? {
+                propertyName: property?.storageName ?? pair.propertyName,
+                seedLocalId,
+                modelType: null,
+                easDataType: null,
+                refValueType: null,
+                refModelUid: null,
+                refSeedType: null,
+                refResolvedValue: null,
+                refResolvedDisplayValue: null,
+                localStorageDir: null,
+                contentHash: null,
+                publisher: null,
+                retract: null,
+            }),
+            propertyValue: recordedValue,
+            localId: generateId(),
+            propertyId: target?.propertyId ?? property?.id ?? null,
+            uid: att,
+            schemaUid: normalizeBytes32Hex(target?.schemaUid) ? target.schemaUid : wantSchema,
+            seedUid: liveSeedUid,
+            versionUid: validVersion,
+            versionLocalId: versionLocalId ?? target?.versionLocalId ?? null,
+            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);
+    }
+}
+/** How a property's value names seeds: one seed (Relation) or a JSON list of them (List of Relation). */
+function refKind(property) {
+    if (!property)
+        return undefined;
+    const dataType = normalizeDataType(property.dataType);
+    if (dataType === 'Relation')
+        return 'relation';
+    if (dataType === 'List' && normalizeDataType(property.refValueType ?? undefined) === 'Relation' && property.ref) {
+        return 'list';
+    }
+    return undefined;
+}
+/**
+ * The seed's model's properties. The model comes from the seed's model_file_id, else a metadata
+ * row's property_id; an unknown model gives none (rows then match by the pair's name alone,
+ * values unchanged).
+ */
+async function loadSeedProperties(appDb, seedLocalId, rows) {
+    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 [];
+        return await readModelMetadataProperties(appDb, modelId);
+    }
+    catch {
+        // Unknown model: match by the pair's name alone.
+        return [];
+    }
+}
+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 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) => !isPlaceholderUid(r.uid))
+        .map((r) => ({ uid: r.uid }));
+};
+
+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 seedRow = await findSeedRow({ localId: seedLocalId, uid: seedUid }, appDb);
+    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(eq(metadata.seedUid, seedUid));
+    return rows
+        .filter((r) => !isPlaceholderUid(r.uid) && r.schemaUid != null)
+        .map((r) => ({ uid: r.uid, schemaUid: r.schemaUid }));
+};
+
+/**
+ * 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); resolved as {@link findSeedRow} resolves it
+ * @returns The attester address, or null if not found or no attester
+ */
+async function getAttesterForSeed(params) {
+    const row = await findSeedRow({ localId: params.seedLocalId, uid: params.seedUid });
+    return row ? resolvePublisherFromSeedRow(row) : null;
+}
+
+/**
+ * Records property attestations publish revoked for a retraction (ADR 0021): their rows get
+ * `revoked_at` and lose their value, as EAS sync stores a property revoked while its seed is live.
+ * The cleared row that asked for the retraction stays the property's newest row.
+ */
+const markPropertyAttestationsRetracted = async ({ uids, revokedAt, }) => {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || uids.length === 0)
+        return;
+    await writeInBatches(uids, (chunk) => appDb
+        .update(metadata)
+        .set({
+        revokedAt,
+        propertyValue: null,
+        refSeedType: null,
+        refResolvedValue: null,
+        refResolvedDisplayValue: null,
+    })
+        .where(and(inArray(metadata.uid, chunk), isNull(metadata.revokedAt))));
+};
+
+/**
+ * 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;
+/** 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);
+}
+/** Bytes an upload carries (a composite's children summed, as before framing). */
+async function sourceBytes(source) {
+    let total = 0;
+    for (const filePath of source.children ? source.children.map((c) => c.filePath) : [source.filePath]) {
+        total += (await BaseFileManager.getFileSize(filePath)) ?? 0;
+    }
+    return total;
+}
+/**
+ * What one property adds to the publish, by the payload's rules: one attestation, the
+ * revocations of a retraction, or nothing.
+ */
+async function propertyWork(node, property, forceFullSnapshot, uploaded) {
+    const none = { attestations: 0, revocations: 0 };
+    const full = node.kind === 'root' || node.kind === 'draft';
+    if (INTERNAL_PROPERTY_NAMES.includes(property.key) || property.deferred)
+        return none;
+    if (property.kind === 'itemStorage')
+        return none;
+    // The storage transaction slot attests this publish's upload of the node's file(s).
+    if (property.kind === 'storageTransaction')
+        return uploaded ? { attestations: 1, revocations: 0 } : none;
+    if (!full && property.kind !== 'basic')
+        return none;
+    const value = property.row?.propertyValue;
+    if (value != null && value !== '')
+        return property.uid && !forceFullSnapshot ? none : { attestations: 1, revocations: 0 };
+    // An empty value attests a removal, or revokes for a retraction (ADR 0021)
+    if (property.uid && !forceFullSnapshot)
+        return none;
+    const clear = await getPropertyClear({
+        seedLocalId: node.seedLocalId,
+        seedUid: node.seedUid,
+        propertyId: property.definition._dbId,
+        modelName: node.modelName,
+        propertyName: property.key,
+        dataType: property.definition.dataType,
+        refValueType: property.definition.refValueType,
+    });
+    if (!clear)
+        return none;
+    return clear.retract ? { attestations: 0, revocations: clear.retractScope.length } : { attestations: 1, revocations: 0 };
+}
+/**
+ * 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) => (await getPublishGraph(item, { publishMode: options?.publishMode })).unpublishedRelatedItems;
+/**
+ * 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 summarizePublishWork = async (item, options) => {
+    const publishMode = options?.publishMode ?? 'patch';
+    const graph = await getPublishGraph(item, { publishMode });
+    const sources = await getPublishUploadSources(graph);
+    const acc = {
+        publishMode,
+        seedCount: graph.nodes.length,
+        newSeedCount: 0,
+        newVersionCount: 0,
+        attestationCount: 0,
+        revocationCount: 0,
+        uploadCount: 0,
+        uploadBytes: 0,
+        uploadSizes: [],
+        unpublishedRelatedItems: graph.unpublishedRelatedItems,
+    };
+    for (const source of sources) {
+        const bytes = await sourceBytes(source);
+        if (bytes <= 0)
+            continue;
+        acc.uploadCount += 1;
+        acc.uploadBytes += bytes;
+        acc.uploadSizes.push(bytes);
+    }
+    for (const node of graph.nodes) {
+        if (node.newSeed)
+            acc.newSeedCount += 1;
+        if (node.newSeed || graph.forceFullSnapshot)
+            acc.newVersionCount += 1;
+        const uploaded = sources.some((s) => s.seedLocalId === node.seedLocalId);
+        for (const property of node.properties) {
+            const work = await propertyWork(node, property, graph.forceFullSnapshot, uploaded);
+            acc.attestationCount += work.attestations;
+            acc.revocationCount += work.revocations;
+        }
+    }
+    return acc;
+};
+
+const logger = debug('seedSdk:helpers:updateSchema');
+// Schema reloads renameModelProperty deferred and that haven't finished yet
+const deferredSchemaReloads = new Set();
+/**
+ * Convert a TProperty/ModelPropertyMachineContext to SchemaPropertyUpdate format
+ * This function converts the internal property representation to the schema file format
+ * @param property - The TProperty instance to convert
+ * @param modelName - The name of the model this property belongs to
+ * @param propertyName - The name of the property
+ * @returns A SchemaPropertyUpdate object ready to be passed to updateModelProperties
+ */
+async function convertPropertyToSchemaUpdate(property, modelName, propertyName) {
+    const updates = {};
+    // Convert dataType to type
+    if (property.dataType) {
+        updates.type = property.dataType;
+    }
+    // Handle Relation type
+    if (isDataType(property.dataType, ModelPropertyDataTypes.Relation)) {
+        if (property.ref) {
+            updates.model = property.ref;
+        }
+        else if (property.refModelId) {
+            // If ref is not set but refModelId is, get the model name from the database
+            const refModelName = (await resolveModelRecord(undefined, { modelId: property.refModelId }))?.name;
+            if (refModelName) {
+                updates.model = refModelName;
+            }
+        }
+    }
+    // Handle List type
+    if (isDataType(property.dataType, ModelPropertyDataTypes.List)) {
+        if (property.refValueType) {
+            updates.refValueType = property.refValueType;
+            if (property.ref) {
+                updates.ref = property.ref;
+            }
+            else if (property.refModelId) {
+                // If ref is not set but refModelId is, get the model name from the database
+                const refModelName = (await resolveModelRecord(undefined, { modelId: property.refModelId }))?.name;
+                if (refModelName) {
+                    updates.ref = refModelName;
+                }
+            }
+        }
+    }
+    // Handle required (validation constraint)
+    if (property.required !== undefined) {
+        updates.required = property.required;
+    }
+    // Handle storage configuration (for Text properties with storage)
+    if (property.storageType || property.localStorageDir || property.filenameSuffix) {
+        const storageType = property.storageType || 'ItemStorage'; // Default to ItemStorage if not specified
+        updates.storage = {
+            type: storageType,
+        };
+        if (property.localStorageDir) {
+            updates.storage.path = property.localStorageDir;
+        }
+        if (property.filenameSuffix) {
+            updates.storage.extension = property.filenameSuffix;
+        }
+    }
+    return {
+        modelName,
+        propertyName,
+        updates,
+    };
+}
+/**
+ * Update model properties in a schema and create a new version
+ * @param schemaName - The name of the schema to update
+ * @param propertyUpdates - Array of property updates to apply
+ * @param modelUpdates - Optional array of model renames
+ * @returns The file path of the new schema version
+ * @throws Error if schema not found or updates are invalid
+ */
+async function updateModelProperties(schemaName, propertyUpdates, modelUpdates) {
+    const modelRenames = new Map();
+    const changes = propertyUpdates.map((update) => ({
+        type: 'property_update',
+        modelName: update.modelName,
+        propertyName: update.propertyName,
+        updates: update.updates,
+    }));
+    const { filePath } = await writeNextSchemaVersion(schemaName, (schema) => {
+        for (const { oldName, newName } of modelUpdates ?? []) {
+            if (!schema.models[oldName])
+                continue;
+            schema.models[newName] = schema.models[oldName];
+            delete schema.models[oldName];
+            // References to the model follow the rename
+            for (const model of Object.values(schema.models)) {
+                for (const property of Object.values(model.properties)) {
+                    if (property.model === oldName)
+                        property.model = newName;
+                    if (property.ref === oldName)
+                        property.ref = newName;
+                    if (property.refModelName === oldName)
+                        property.refModelName = newName;
+                    if (property.items?.model === oldName)
+                        property.items.model = newName;
+                }
+            }
+            modelRenames.set(oldName, newName);
+            changes.push({ type: 'model_rename', oldName, newName });
+        }
+        for (const update of propertyUpdates) {
+            const model = schema.models[update.modelName];
+            if (!model) {
+                throw new Error(`Model ${update.modelName} not found in schema ${schemaName}`);
+            }
+            const property = model.properties[update.propertyName];
+            if (!property) {
+                throw new Error(`Property ${update.propertyName} not found in model ${update.modelName} of schema ${schemaName}`);
+            }
+            const { type, ...updates } = update.updates;
+            // One key per field: a property written with `dataType` takes the new type there
+            if (type !== undefined)
+                property[property.dataType !== undefined ? 'dataType' : 'type'] = type;
+            Object.assign(property, updates);
+        }
+        return schema;
+    }, {
+        description: `Updated model properties: ${propertyUpdates.map((u) => `${u.modelName}.${u.propertyName}`).join(', ')}`,
+        changes,
+        modelRenames,
+    });
+    return filePath;
+}
+/**
+ * Rename a property in a model, keeping its id: writes the next schema version, moves the
+ * property's metadata rows to the new name, then applies the version to the rows.
+ * @param schemaName - The name of the schema
+ * @param modelName - The name of the model
+ * @param oldPropertyName - The current property name
+ * @param newPropertyName - The new property name
+ * @returns The file path of the new schema version
+ */
+async function renameModelProperty(schemaName, modelName, oldPropertyName, newPropertyName) {
+    const { schemaFile, filePath } = await writeNextSchemaVersion(schemaName, (schema) => {
+        const model = schema.models[modelName];
+        if (!model) {
+            throw new Error(`Model ${modelName} not found in schema ${schemaName}`);
+        }
+        if (!model.properties[oldPropertyName]) {
+            throw new Error(`Property ${oldPropertyName} not found in model ${modelName} of schema ${schemaName}`);
+        }
+        if (model.properties[newPropertyName]) {
+            throw new Error(`Property ${newPropertyName} already exists in model ${modelName} of schema ${schemaName}`);
+        }
+        // Same position, new key
+        model.properties = Object.fromEntries(Object.entries(model.properties).map(([name, prop]) => [name === oldPropertyName ? newPropertyName : name, prop]));
+        return schema;
+    }, {
+        description: `Renamed property ${modelName}.${oldPropertyName} to ${newPropertyName}`,
+        changes: [{ type: 'property_rename', modelName, oldPropertyName, newPropertyName }],
+        apply: false,
+    });
+    logger(`Renamed property ${oldPropertyName} to ${newPropertyName} in schema ${schemaName} v${schemaFile.version}`);
+    // Item values follow the property by property_id (decision D4); only pending edits name it
+    const _mod_0 = await import('./tabEvents-CaVmngqr.js');
+    const _ns_0 = _mod_0.bh;
+    const { renamePendingWritesForProperty } = _ns_0;
+    await renamePendingWritesForProperty(modelName, oldPropertyName, newPropertyName);
+    // Applied after a delay: applying posts to BroadcastChannel and causes React invalidates, and
+    // running that inside the caller's save flow froze it (updateContext/refetch loops).
+    const reload = new Promise((resolve) => setTimeout(resolve, 100))
+        .then(() => applySchemaFile(schemaFile, { store: false }))
+        .then(() => { }, (err) => {
+        logger('Deferred schema apply after rename failed:', err);
+    })
+        .finally(() => deferredSchemaReloads.delete(reload));
+    deferredSchemaReloads.add(reload);
+    return filePath;
+}
+
+var updateSchema = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    convertPropertyToSchemaUpdate: convertPropertyToSchemaUpdate,
+    renameModelProperty: renameModelProperty,
+    updateModelProperties: updateModelProperties
+});
+
+export { applyPropertyAttestationUidsFromPublish as a, getMetadataAttestationUidsForSeedUid as b, getSeedPublishState as c, getUnpublishedRelatedItems as d, estimateDataUriByteLength as e, getVersionsForSeedUid as f, getAttesterForSeed as g, resolveMediaRef as h, updateVersionUid as i, updateSchema as j, markPropertyAttestationsRetracted as m, renameModelProperty as r, summarizePublishWork as s, updateModelProperties as u };
+//# sourceMappingURL=index-DmTtj1nk.js.map