@seedprotocol/sdk 0.7.9 → 0.7.10-next.1344.g3828e8a

package/dist/{index-DmTtj1nk.js → index-CVYB2g7a.js}

@@ -1,21 +1,22 @@
-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 { w as writeNextSchemaVersion, o as applySchemaFile } from './errors-DpC9W4i3.js';
+import { a7 as convertTxIdToImage, x as normalizePublisher, m as generateId, n as normalizeDataType, j as findSeedRow, V as resolveUploadMimeType, R as getExtensionForMimeType, w as writeInBatches, a0 as INTERNAL_PROPERTY_NAMES, i as isDataType, M as ModelPropertyDataTypes, r as resolveModelRecord } from './tabEvents-BHPY5I08.js';
+import './property-QjljUeb9.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-DLou1TZS.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 storedValueKind, ac as storageSeedTransactionId, as as resolveStorageDisplay, at as resolvePublisherFromSeedRow } from './Item-CXLcIHsi.js';
 import { eq, and, inArray, or, isNull } from 'drizzle-orm';
-import { classifyMediaRef, BaseArweaveClient } from '@seedprotocol/arweave';
+import { classifyMediaRef, BaseArweaveClient, resolveSeedIdsFromRefString, normalizeRelationPropertyValue, getPublicArweaveRawUrl } 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 { isPlaceholderUid, isValidEasAttestationUid, normalizeBytes32Hex, getEasReadChainId, getEasChainDeployment, getEasAttestationExplorerUrl } from '@seedprotocol/eas';
+import './Schema-BeUyEmte.js';
+import { rewriteHtmlUrls, parseArchiveDocument, dublinCoreXml, premisXml, digestHex, createBag } from '@seedprotocol/archive';
+import { g as getPublishGraph } from './publishGraph-CP8IROkb.js';
+import { r as resolveItemStorageChildFile, S as SEED_PROPERTY_REF_PREFIX, f as findEmbeddedImageFilePath, g as getPublishUploadSources } from './getPublishUploads-BdZmYCo2.js';
+import './browserSupport-C64rX-2I.js';
+import './updateSeedRevokedAt-BMwBnlnC.js';
+import './ModelProperty-B3mfR6u4.js';
+import './eas-DpHg66jR.js';
+import './getPublishPendingDiff-D__9bh6d.js';
+import { g as getPropertyClear } from './getPublishPayload-yidQCgY_.js';
 import debug from 'debug';
 
 /** Classification and feed-field helpers live in `@seedprotocol/arweave`; resolving needs the local DB and files. */
@@ -379,6 +380,387 @@ async function toAttestedRefValue(appDb, raw, kind, resolvedSeedUids) {
     return value === raw ? undefined : value;
 }
 
+const getMetadata = async (props) => {
+    const appDb = BaseDb.getAppDb();
+    let storageTransactionId;
+    if (props) {
+        storageTransactionId = props.storageTransactionId;
+    }
+    const whereClauses = [];
+    if (storageTransactionId) {
+        whereClauses.push(eq(metadata.propertyName, 'storageTransactionId'));
+        whereClauses.push(eq(metadata.propertyValue, storageTransactionId));
+    }
+    const metadataRows = await appDb
+        .select()
+        .from(metadata)
+        .where(and(...whereClauses));
+    if (!metadataRows || metadataRows.length === 0) {
+        return;
+    }
+    return metadataRows[0];
+};
+
+/** The item can't be exported as it is. `code` says why. */
+class ArchiveExportError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ArchiveExportError';
+        this.code = code;
+    }
+}
+const ARWEAVE_TX_ID = /^[a-z0-9_-]{43}$/i;
+const SOFTWARE_AGENT = '@seedprotocol/sdk exportArchive (https://github.com/JournoLabs/seed-protocol-sdk)';
+const isoFromMs = (ms) => typeof ms === 'number' && Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : undefined;
+const toBytes = async (data) => typeof Blob !== 'undefined' && data instanceof Blob ? new Uint8Array(await data.arrayBuffer()) : new Uint8Array(data);
+const readBytes = async (filePath) => toBytes(await BaseFileManager.readFileAsBuffer(filePath));
+/** The Arweave transaction id a gateway URL serves (`https://<host>/<tx>` or `/raw/<tx>`), if it is one. */
+function arweaveTxIdOfUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+            return undefined;
+        const segments = parsed.pathname.split('/').filter(Boolean);
+        const last = segments[segments.length - 1];
+        const isTxPath = segments.length === 1 || (segments.length === 2 && segments[0] === 'raw');
+        return isTxPath && last && ARWEAVE_TX_ID.test(last) ? last : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const hasValue = (value) => value != null && value !== '';
+/** A saved local value that no attestation backs: the bag would mix it with the published record. */
+const isUnpublishedEdit = (property) => {
+    const row = property.row;
+    return !!row && !property.deferred && !row.uid && row.derivedFromUid == null && hasValue(row.propertyValue);
+};
+/**
+ * Builds the bag for `item`'s current published state:
+ *
+ * - `data/index.html` (or `data/<property>.html` when the model has several Html properties): the
+ *   Html with references to files in the bag rewritten to relative paths.
+ * - `data/source/<property>.html`: each Html exactly as published.
+ * - `data/assets/<sha256>.<ext>`: Images, Files and images the Html references.
+ * - `data/item.json`: every property's value, attestation uid and Arweave transaction.
+ * - `metadata/dc.xml` and `metadata/premis.xml`.
+ *
+ * Throws {@link ArchiveExportError} `not_published` for an item without a live published version,
+ * and `unpublished_changes` when a property holds a saved value that isn't published yet.
+ * A file that can't be read or downloaded is left out and reported in `omitted`, not thrown.
+ */
+async function exportArchive(item, options = {}) {
+    const fetch = options.fetch ?? true;
+    const now = options.baggingDate ?? new Date();
+    const graph = await getPublishGraph(item);
+    const root = graph.root;
+    const seedRow = await findSeedRow({ localId: root.seedLocalId });
+    const seedUid = root.seedUid;
+    const version = await getLatestPublishedVersionRow(root.seedLocalId);
+    if (!seedUid || !isValidEasAttestationUid(seedUid) || seedRow?.revokedAt || !version) {
+        throw new ArchiveExportError('not_published', `${root.modelName} ${root.seedLocalId} has no live published version`);
+    }
+    const unpublished = root.properties.filter(isUnpublishedEdit).map((p) => p.key);
+    if (unpublished.length > 0) {
+        throw new ArchiveExportError('unpublished_changes', `${root.modelName} ${root.seedLocalId} has unpublished changes to ${unpublished.join(', ')}; publish them first`);
+    }
+    const chainId = getEasReadChainId();
+    const chain = getEasChainDeployment(chainId);
+    const explorerUrl = (uid) => (chain ? getEasAttestationExplorerUrl(chain, uid) : undefined);
+    const schemaName = item.getService?.().getSnapshot().context.schemaName;
+    const attester = seedRow?.publisher ?? undefined;
+    const omitted = [];
+    const payload = [];
+    const fileInfo = new Map();
+    const assetPathByTx = new Map();
+    const assetPathByProperty = new Map();
+    const htmlSources = [];
+    const properties = {};
+    const addAsset = (bytes, mimeType, arweaveTransactionId) => {
+        const ext = getExtensionForMimeType(mimeType);
+        const path = `assets/${digestHex('sha256', bytes)}${ext ? `.${ext}` : ''}`;
+        if (!payload.some((f) => f.path === path)) {
+            payload.push({ path, bytes });
+            fileInfo.set(path, { mimeType, arweaveTransactionId });
+        }
+        if (arweaveTransactionId)
+            assetPathByTx.set(arweaveTransactionId, path);
+        return path;
+    };
+    for (const property of root.properties) {
+        const { key, definition: def, kind, row } = property;
+        const dataType = normalizeDataType(def.dataType) ?? String(def.dataType);
+        const entry = {
+            dataType,
+            attestationUid: row?.uid ?? row?.derivedFromUid ?? undefined,
+            attestedAt: isoFromMs(row?.attestationCreatedAt),
+        };
+        properties[key] = entry;
+        if (kind === 'basic' || kind === 'storageTransaction') {
+            entry.value = row?.propertyValue ?? null;
+            continue;
+        }
+        if (kind === 'relation' || kind === 'list') {
+            entry.value = kind === 'list' ? property.refs.map((r) => r.ref) : (property.refs[0]?.ref ?? null);
+            continue;
+        }
+        if (kind === 'itemStorage') {
+            const { filePath } = await resolveItemStorageChildFile(root, property);
+            if (!filePath) {
+                if (row && hasValue(row.propertyValue))
+                    omitted.push({ property: key, reason: 'its file is not on this device' });
+                continue;
+            }
+            const bytes = await readBytes(filePath);
+            if (dataType === 'Html') {
+                htmlSources.push({ key, text: new TextDecoder().decode(bytes) });
+            }
+            else {
+                const mimeType = resolveUploadMimeType({ fileName: filePath, bytes }) ?? 'application/octet-stream';
+                entry.file = addAsset(bytes, mimeType);
+                assetPathByProperty.set(key, entry.file);
+            }
+            continue;
+        }
+        // storageSeed: the value is a storage seed whose own row records the Arweave transaction.
+        if (!row || !hasValue(row.propertyValue))
+            continue;
+        const storageKind = storedValueKind(def, row);
+        if (!storageKind || storageKind === 'itemStorage') {
+            omitted.push({ property: key, reason: `${dataType} storage seeds are not exported yet` });
+            continue;
+        }
+        const arweaveTransactionId = await storageSeedTransactionId(resolveSeedIdsFromRefString(normalizeRelationPropertyValue(row.propertyValue) ?? ''));
+        if (arweaveTransactionId)
+            entry.arweaveTransactionId = arweaveTransactionId;
+        const display = await resolveStorageDisplay(storageKind, row, { fetch });
+        if (storageKind === 'html') {
+            const text = display.filePath ? await BaseFileManager.readFileAsString(display.filePath) : display.renderValue;
+            if (text === undefined) {
+                omitted.push({ property: key, reason: 'its Html could not be read or downloaded' });
+                continue;
+            }
+            htmlSources.push({ key, text, arweaveTransactionId });
+            continue;
+        }
+        if (!display.filePath) {
+            omitted.push({ property: key, reason: 'its file could not be read or downloaded' });
+            continue;
+        }
+        const bytes = await readBytes(display.filePath);
+        const mimeType = resolveUploadMimeType({ fileName: display.filePath, bytes }) ?? 'application/octet-stream';
+        entry.file = addAsset(bytes, mimeType, arweaveTransactionId);
+        assetPathByProperty.set(key, entry.file);
+    }
+    /** The bag path for an image the Html names by transaction id but no property holds (an embedded image). */
+    const embeddedAssetPath = async (txId) => {
+        const known = assetPathByTx.get(txId);
+        if (known)
+            return known;
+        const imageRow = await getMetadata({ storageTransactionId: txId });
+        let filePath = imageRow?.seedLocalId ? await findEmbeddedImageFilePath(imageRow.seedLocalId) : undefined;
+        if (!filePath) {
+            const display = await resolveStorageDisplay('image', { refResolvedValue: txId, localStorageDir: '/images' }, { fetch });
+            filePath = display.filePath;
+        }
+        if (!filePath)
+            return undefined;
+        const bytes = await readBytes(filePath);
+        const mimeType = resolveUploadMimeType({ fileName: filePath, bytes }) ?? 'application/octet-stream';
+        return addAsset(bytes, mimeType, txId);
+    };
+    const encoder = new TextEncoder();
+    for (const html of htmlSources) {
+        const targets = new Map();
+        // Collect first: rewriteHtmlUrls takes a synchronous mapping.
+        rewriteHtmlUrls(html.text, (url) => {
+            targets.set(url, url);
+            return undefined;
+        });
+        for (const url of targets.keys()) {
+            if (url.startsWith(SEED_PROPERTY_REF_PREFIX)) {
+                const path = assetPathByProperty.get(url.slice(SEED_PROPERTY_REF_PREFIX.length));
+                if (path)
+                    targets.set(url, path);
+                else
+                    targets.delete(url);
+                continue;
+            }
+            const txId = arweaveTxIdOfUrl(url);
+            const path = txId ? await embeddedAssetPath(txId) : undefined;
+            if (path)
+                targets.set(url, path);
+            else {
+                targets.delete(url);
+                if (txId)
+                    omitted.push({ property: html.key, reason: `references ${url}, which is not in the bag` });
+            }
+        }
+        const rewritten = rewriteHtmlUrls(html.text, (url) => targets.get(url));
+        const viewPath = htmlSources.length === 1 ? 'index.html' : `${html.key}.html`;
+        payload.push({ path: viewPath, bytes: encoder.encode(rewritten) });
+        fileInfo.set(viewPath, { mimeType: 'text/html' });
+        const sourcePath = `source/${html.key}.html`;
+        payload.push({ path: sourcePath, bytes: encoder.encode(html.text) });
+        fileInfo.set(sourcePath, { mimeType: 'text/html', arweaveTransactionId: html.arweaveTransactionId });
+        properties[html.key].file = sourcePath;
+    }
+    const itemJson = {
+        seedUid,
+        versionUid: version.uid,
+        schemaName,
+        modelName: root.modelName,
+        chain: { id: chainId, name: chain?.name },
+        attester,
+        properties,
+        omitted,
+    };
+    payload.push({ path: 'item.json', bytes: encoder.encode(`${JSON.stringify(itemJson, null, 2)}\n`) });
+    fileInfo.set('item.json', { mimeType: 'application/json' });
+    // Descriptive metadata comes from the archive document, so nothing is guessed from property names.
+    const primary = htmlSources[0];
+    const doc = primary ? parseArchiveDocument(primary.text) : undefined;
+    const versionDate = isoFromMs(version.attestationCreatedAt);
+    const dc = dublinCoreXml({
+        title: doc?.name,
+        creator: doc?.authors,
+        description: doc?.summary,
+        date: doc?.published ?? versionDate?.slice(0, 10),
+        type: 'Text',
+        format: primary ? 'text/html' : undefined,
+        identifier: [seedUid, explorerUrl(seedUid)].filter((v) => !!v),
+        source: doc?.url,
+    });
+    const premis = premisXml({
+        objects: [
+            {
+                kind: 'intellectualEntity',
+                identifiers: [
+                    { type: 'Seed Protocol seed UID', value: seedUid },
+                    { type: 'Seed Protocol version UID', value: version.uid },
+                ],
+            },
+            ...payload.map((file) => {
+                const info = fileInfo.get(file.path);
+                return {
+                    kind: 'file',
+                    identifiers: [{ type: 'bag path', value: `data/${file.path}` }],
+                    fixity: { 'SHA-256': digestHex('sha256', file.bytes), 'SHA-512': digestHex('sha512', file.bytes) },
+                    size: file.bytes.byteLength,
+                    formatName: info?.mimeType ?? 'application/octet-stream',
+                    originalName: info?.arweaveTransactionId ? getPublicArweaveRawUrl(info.arweaveTransactionId) : undefined,
+                };
+            }),
+        ],
+        events: [...(await historyEvents(root.seedLocalId, seedUid, version, attester)), ...bagEvents(now, seedUid)],
+        agents: [
+            ...(attester
+                ? [{ identifiers: [{ type: 'EVM address', value: attester }], note: `EAS attester on chain ${chainId}` }]
+                : []),
+            { identifiers: [{ type: 'software', value: '@seedprotocol/sdk' }], name: '@seedprotocol/sdk', type: 'software' },
+        ],
+    });
+    const info = [];
+    if (options.sourceOrganization)
+        info.push(['Source-Organization', options.sourceOrganization]);
+    info.push(['External-Identifier', seedUid]);
+    if (doc?.name)
+        info.push(['External-Description', doc.name]);
+    info.push(['Seed-Uid', seedUid], ['Seed-Version-Uid', version.uid], ['Seed-Model', root.modelName]);
+    if (schemaName)
+        info.push(['Seed-Schema', schemaName]);
+    info.push(['EAS-Chain-Id', String(chainId)]);
+    if (chain?.name)
+        info.push(['EAS-Chain-Name', chain.name]);
+    if (attester)
+        info.push(['EAS-Attester', attester]);
+    const bag = createBag({
+        payload,
+        tagFiles: [
+            { path: 'metadata/dc.xml', bytes: encoder.encode(dc) },
+            { path: 'metadata/premis.xml', bytes: encoder.encode(premis) },
+        ],
+        info,
+        baggingDate: now,
+        softwareAgent: SOFTWARE_AGENT,
+    });
+    return { bag, omitted };
+}
+/**
+ * The seed's attested history: its first live Version as creation, later Versions and property
+ * attestations made after the current Version (patches) as modifications. Attestations without
+ * a recorded time are left out, since PREMIS events need one.
+ */
+async function historyEvents(seedLocalId, seedUid, current, attester) {
+    const db = BaseDb.getAppDb();
+    const agents = attester ? [{ type: 'EVM address', value: attester, role: 'attester' }] : [];
+    const objects = [{ type: 'Seed Protocol seed UID', value: seedUid }];
+    const versionRows = (await db
+        .select({ uid: versions.uid, attestationCreatedAt: versions.attestationCreatedAt, revokedAt: versions.revokedAt })
+        .from(versions)
+        .where(eq(versions.seedLocalId, seedLocalId)))
+        .filter((v) => isValidEasAttestationUid(v.uid) && v.attestationCreatedAt)
+        .sort((a, b) => a.attestationCreatedAt - b.attestationCreatedAt);
+    const events = versionRows.map((v, index) => ({
+        identifier: { type: 'EAS attestation UID', value: v.uid },
+        type: index === 0 ? 'creation' : 'modification',
+        dateTime: isoFromMs(v.attestationCreatedAt),
+        detail: index === 0 ? 'First Version attested' : 'New Version attested',
+        outcome: 'success',
+        outcomeNote: v.revokedAt ? `Version revoked at ${new Date(v.revokedAt * 1000).toISOString()}` : undefined,
+        agents,
+        objects,
+    }));
+    if (current.attestationCreatedAt) {
+        const patches = (await db
+            .select({ uid: metadata.uid, propertyName: metadata.propertyName, attestationCreatedAt: metadata.attestationCreatedAt })
+            .from(metadata)
+            .where(and(eq(metadata.seedLocalId, seedLocalId), eq(metadata.versionUid, current.uid))));
+        for (const row of patches) {
+            if (!isValidEasAttestationUid(row.uid) || !row.attestationCreatedAt)
+                continue;
+            if (row.attestationCreatedAt <= current.attestationCreatedAt)
+                continue;
+            events.push({
+                identifier: { type: 'EAS attestation UID', value: row.uid },
+                type: 'modification',
+                dateTime: isoFromMs(row.attestationCreatedAt),
+                detail: `Property ${row.propertyName} attested again on Version ${current.uid}`,
+                outcome: 'success',
+                agents,
+                objects,
+            });
+        }
+    }
+    return events.sort((a, b) => a.dateTime.localeCompare(b.dateTime));
+}
+/** The bag's own events: its checksums and the package itself. */
+const bagEvents = (now, seedUid) => {
+    const agents = [{ type: 'software', value: '@seedprotocol/sdk', role: 'executing program' }];
+    const objects = [{ type: 'Seed Protocol seed UID', value: seedUid }];
+    const dateTime = now.toISOString();
+    return [
+        {
+            identifier: { type: 'bag event', value: `message-digest-${dateTime}` },
+            type: 'message digest calculation',
+            dateTime,
+            detail: 'SHA-256 and SHA-512 of every payload and tag file',
+            outcome: 'success',
+            agents,
+            objects,
+        },
+        {
+            identifier: { type: 'bag event', value: `package-${dateTime}` },
+            type: 'information package creation',
+            dateTime,
+            detail: 'BagIt 1.0 bag written by exportArchive',
+            outcome: 'success',
+            agents,
+            objects,
+        },
+    ];
+};
+
 const getVersionsForSeedUid = async (seedUid) => {
     if (!seedUid)
         return [];
@@ -790,8 +1172,8 @@ async function renameModelProperty(schemaName, modelName, oldPropertyName, newPr
     });
     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 _mod_0 = await import('./tabEvents-BHPY5I08.js');
+    const _ns_0 = _mod_0.bk;
     const { renamePendingWritesForProperty } = _ns_0;
     await renamePendingWritesForProperty(modelName, oldPropertyName, newPropertyName);
     // Applied after a delay: applying posts to BroadcastChannel and causes React invalidates, and
@@ -813,5 +1195,5 @@ var updateSchema = /*#__PURE__*/Object.freeze({
     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
+export { ArchiveExportError as A, applyPropertyAttestationUidsFromPublish as a, exportArchive as b, getMetadataAttestationUidsForSeedUid as c, getSeedPublishState as d, estimateDataUriByteLength as e, getUnpublishedRelatedItems as f, getAttesterForSeed as g, getVersionsForSeedUid as h, resolveMediaRef as i, updateVersionUid as j, updateSchema as k, markPropertyAttestationsRetracted as m, renameModelProperty as r, summarizePublishWork as s, updateModelProperties as u };
+//# sourceMappingURL=index-CVYB2g7a.js.map