@seedprotocol/sdk 0.6.6 → 0.6.8

package/dist/index-280bL-n4.js

@@ -0,0 +1,1122 @@
+import debug from 'debug';
+import { a as BaseDb, b as metadata, B as BaseFileManager, c as appState, C as ImageSize } from './BasePathResolver-B6CKqoKw.js';
+import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls } from '@seedprotocol/arweave';
+import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
+import { waitFor } from 'xstate';
+import 'pluralize';
+import { p as getAllAddressesFromDb } from './db-WbrzEf7c.js';
+import { and, eq, or, isNotNull } from 'drizzle-orm';
+import 'nanoid';
+import 'nanoid-dictionary';
+import '@seedprotocol/query';
+import { throttle } from 'lodash-es';
+
+/** Same rules as getCorrectId in helpers/index (avoid barrel circular import). */
+function parseLocalIdOrUid(localIdOrUid) {
+    const id = { localId: undefined, uid: undefined };
+    if (!localIdOrUid)
+        return id;
+    if (localIdOrUid.length === 10) {
+        id.localId = localIdOrUid;
+    }
+    if (localIdOrUid.startsWith('0x') && localIdOrUid.length === 66) {
+        id.uid = localIdOrUid;
+    }
+    return id;
+}
+/** Relation/image refs may be string ids or `{ seedLocalId?, seedUid? }`. */
+function normalizeRelationPropertyValue(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string') {
+        const t = value.trim();
+        return t !== '' ? t : undefined;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const o = value;
+        if (typeof o.seedLocalId === 'string' && o.seedLocalId.trim() !== '') {
+            return o.seedLocalId.trim();
+        }
+        if (typeof o.seedUid === 'string' && o.seedUid.trim() !== '') {
+            return o.seedUid.trim();
+        }
+    }
+    return undefined;
+}
+/** getCorrectId only accepts 10-char local ids and 0x66 uids; local seed refs can be up to 21 chars. */
+const LOCAL_SEED_REF = /^[a-zA-Z0-9_-]{10,21}$/;
+/** Resolve seed ids from a single string (context propertyValue or DB row). */
+function resolveSeedIdsFromRefString(s) {
+    const fromCorrect = parseLocalIdOrUid(s);
+    if (fromCorrect.localId || fromCorrect.uid) {
+        return { seedLocalId: fromCorrect.localId, seedUid: fromCorrect.uid };
+    }
+    if (LOCAL_SEED_REF.test(s) && !s.startsWith('0x')) {
+        return { seedLocalId: s };
+    }
+    return {};
+}
+/**
+ * True when a relation ref is an attested seed uid (0x…) rather than a local id. A uid only exists once
+ * the seed is on EAS, so publish can attest the uid as-is when no local copy exists (e.g. a server
+ * publishing on someone's behalf that only holds the uids it was given). Callers must not walk into it.
+ */
+function isPublishedSeedRef(value) {
+    const ref = normalizeRelationPropertyValue(value);
+    if (!ref)
+        return false;
+    const { seedLocalId, seedUid } = resolveSeedIdsFromRefString(ref);
+    return !!seedUid && !seedLocalId;
+}
+/**
+ * Storage seed local id (nanoid) or 0x uid. Stricter than resolveSeedIdsFromRefString, which accepts
+ * any 10-char string (so a 10-char html snippet like "<p>raw</p>" would pass as a local id).
+ */
+const STORAGE_SEED_REF = /^(?:[A-Za-z0-9_-]{10,21}|0x[0-9a-fA-F]{64})$/;
+/** True when a File/Image/Html value is already a storage seed reference rather than raw content. */
+function isStorageSeedRef(value) {
+    return typeof value === 'string' && STORAGE_SEED_REF.test(value.trim());
+}
+
+const seedUidToStorageTransactionId = new Map();
+const getStorageTransactionIdForSeedUid = async (seedUid) => {
+    if (seedUidToStorageTransactionId.has(seedUid)) {
+        return seedUidToStorageTransactionId.get(seedUid);
+    }
+    const appDb = BaseDb.getAppDb();
+    const results = (await appDb
+        .select({
+        storageTransactionId: metadata.propertyValue,
+    })
+        .from(metadata)
+        .where(and(eq(metadata.seedUid, seedUid), eq(metadata.propertyName, 'storageTransactionId'))));
+    if (!results || results.length === 0) {
+        return;
+    }
+    seedUidToStorageTransactionId.set(seedUid, results[0].storageTransactionId);
+    return results[0].storageTransactionId;
+};
+
+const logger$3 = debug('seedSdk:helpers:mediaRef');
+/** Typical Arweave transaction id: 43 URL-safe base64 characters. */
+const ARWEAVE_TX_ID = /^[a-zA-Z0-9_-]{43}$/;
+function trimOrEmpty(raw) {
+    if (raw == null)
+        return '';
+    return typeof raw === 'string' ? raw.trim() : String(raw).trim();
+}
+function coalesceStringField(item, key) {
+    const v = item[key];
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v.trim();
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return '';
+}
+/**
+ * Try JSON relation payloads and plain relation id strings.
+ */
+function unwrapRelationString(raw) {
+    const t = raw.trim();
+    if (!t)
+        return t;
+    try {
+        const parsed = JSON.parse(t);
+        const fromObj = normalizeRelationPropertyValue(parsed);
+        if (fromObj)
+            return fromObj;
+    }
+    catch {
+        // not JSON
+    }
+    return t;
+}
+/**
+ * Pure, sync classification of a media-related string from feeds or XML.
+ */
+function classifyMediaRef(raw, options) {
+    const s = trimOrEmpty(raw);
+    if (!s) {
+        return { kind: 'empty' };
+    }
+    const treatAs = options?.treatAs;
+    if (treatAs === 'url') {
+        return { kind: 'url', href: s };
+    }
+    if (treatAs === 'arweaveTx') {
+        return { kind: 'arweaveTxId', txId: s };
+    }
+    if (treatAs === 'seedUid') {
+        if (s.startsWith('0x') && s.length === 66) {
+            return { kind: 'seedUid', uid: s };
+        }
+        return { kind: 'unknown', raw: s };
+    }
+    if (s.startsWith('http://') || s.startsWith('https://') || s.startsWith('blob:') || s.startsWith('data:')) {
+        if (isEasAttestationExplorerUrl(s)) {
+            return { kind: 'nonMediaUrl', href: s };
+        }
+        return { kind: 'url', href: s };
+    }
+    const unwrapped = unwrapRelationString(s);
+    const ids = resolveSeedIdsFromRefString(unwrapped);
+    if (ids.seedUid) {
+        return { kind: 'seedUid', uid: ids.seedUid };
+    }
+    if (ids.seedLocalId) {
+        return { kind: 'seedLocalId', localId: ids.seedLocalId };
+    }
+    if (unwrapped.startsWith('0x') && unwrapped.length === 66) {
+        return { kind: 'seedUid', uid: unwrapped };
+    }
+    if (ARWEAVE_TX_ID.test(unwrapped) && !unwrapped.startsWith('0x')) {
+        return { kind: 'arweaveTxId', txId: unwrapped };
+    }
+    return { kind: 'unknown', raw: s };
+}
+/**
+ * Same as convertTxIdToImage but local to this module to avoid circular imports with helpers/index.
+ */
+async function tryLocalBlobUrlFromTxId(txId) {
+    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
+    const fileExists = await BaseFileManager.pathExists(imageFilePath);
+    if (!fileExists) {
+        logger$3(`[tryLocalBlobUrlFromTxId] ${imageFilePath} does not exist`);
+        return undefined;
+    }
+    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
+    let arrayBuffer;
+    if (buffer instanceof Blob) {
+        arrayBuffer = await buffer.arrayBuffer();
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        arrayBuffer = buffer;
+    }
+    else {
+        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        if (sliced instanceof SharedArrayBuffer) {
+            const uint8Array = new Uint8Array(sliced);
+            arrayBuffer = uint8Array.buffer.slice(0);
+        }
+        else {
+            arrayBuffer = sliced;
+        }
+    }
+    const uint = new Uint8Array(arrayBuffer);
+    const imageBlob = new Blob([uint]);
+    return URL.createObjectURL(imageBlob);
+}
+async function resolveTxId(txId) {
+    const local = await tryLocalBlobUrlFromTxId(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.
+ */
+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,
+            };
+    }
+}
+/**
+ * Read a string field from a parsed item, trying camelCase and snake_case keys.
+ */
+function getFeedItemStringField(item, key) {
+    const direct = coalesceStringField(item, key);
+    if (direct)
+        return direct;
+    const snake = key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`);
+    if (snake !== key) {
+        const alt = coalesceStringField(item, snake);
+        if (alt)
+            return alt;
+    }
+    const parts = key.split('_');
+    if (parts.length > 1) {
+        const camel = parts[0] + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+        const alt2 = coalesceStringField(item, camel);
+        if (alt2)
+            return alt2;
+    }
+    return '';
+}
+/**
+ * Apply a field manifest to a plain feed item: classify media/file fields; pass through html/text.
+ */
+function normalizeFeedItemFields(item, manifest) {
+    const out = {};
+    for (const [fieldKey, descriptor] of Object.entries(manifest)) {
+        const raw = getFeedItemStringField(item, fieldKey);
+        if (!raw) {
+            out[fieldKey] = undefined;
+            continue;
+        }
+        if (descriptor.role === 'html') {
+            out[fieldKey] = { role: 'html', raw };
+            continue;
+        }
+        if (descriptor.role === 'text') {
+            out[fieldKey] = { role: 'text', raw };
+            continue;
+        }
+        const classification = classifyMediaRef(raw, { treatAs: descriptor.treatAs });
+        out[fieldKey] = {
+            role: descriptor.role,
+            raw,
+            classification,
+        };
+    }
+    return out;
+}
+
+class SeedEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+        return this;
+    }
+    addListener(event, listener) {
+        return this.on(event, listener);
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return this;
+        set.delete(listener);
+        if (set.size === 0)
+            this.listeners.delete(event);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (typeof event === 'undefined') {
+            this.listeners.clear();
+            return this;
+        }
+        this.listeners.delete(event);
+        return this;
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set || set.size === 0)
+            return false;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+        return true;
+    }
+}
+const eventEmitter = new SeedEventEmitter();
+
+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];
+};
+
+const saveMetadata = async (metadataRecord, metadataValues) => {
+    if (!metadataRecord.localId) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    await appDb
+        .update(metadata)
+        .set({
+        ...metadataValues,
+        updatedAt: Date.now(),
+    })
+        .where(eq(metadata.localId, metadataRecord.localId));
+};
+
+const isNode = () => {
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
+};
+const isBrowser = () => {
+    return !isElectron() && typeof document !== 'undefined' && typeof window !== 'undefined';
+};
+const isElectron = () => {
+    return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
+};
+/**
+ * Detects if code is running in an Electron renderer process.
+ *
+ * Uses multiple detection methods for robustness:
+ * 1. Checks process.type === 'renderer' (most reliable)
+ * 2. Falls back to checking if Electron is present and window/document exist
+ *
+ * @returns true if running in Electron renderer process, false otherwise
+ */
+const isElectronRenderer = () => {
+    // Method 1: Check process.type (most reliable - official Electron API)
+    if (typeof process !== 'undefined' &&
+        process.type === 'renderer') {
+        return true;
+    }
+    // Method 2: Fallback - Electron + browser-like environment
+    // Renderer processes have window/document, main process doesn't (in modern Electron)
+    if (isElectron() &&
+        typeof window !== 'undefined' &&
+        typeof document !== 'undefined') {
+        return true;
+    }
+    return false;
+};
+/**
+ * True where OPFS-backed Arweave file downloads should run: normal browsers and
+ * Electron renderer. {@link isBrowser} is false for every Electron build (including renderer).
+ */
+const supportsOpfsFileDownloads = () => {
+    return isBrowser() || isElectronRenderer();
+};
+
+const logger$2 = debug('seedSdk:files:download');
+const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
+/** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
+const GET_FILES_METADATA_STALE_MS = 120000;
+let bulkDownloadInFlight = null;
+const lazyDownloadInFlightByTransactionId = new Map();
+// syncDbFiles helper - internal service removed, functionality moved here
+const syncDbFiles = async (endpoints) => {
+    // TODO: Implement syncDbFiles functionality if needed
+    // This was previously in @/services/internal/helpers
+    logger$2('[download] syncDbFiles called but not yet implemented');
+    return Promise.resolve();
+};
+const getAppDbReady = async () => {
+    if (!BaseDb.isAppDbReady()) {
+        // Wait for ClientManager to be ready (DB_INIT state or later)
+        const _mod_0 = await import('./ClientManager-ChcmUL47.js');
+        const _ns_0 = _mod_0.ap;
+        const clientManagerMod = _ns_0;
+        const { getClient } = clientManagerMod;
+        const clientManager = getClient();
+        const clientService = clientManager.getService();
+        await waitFor(clientService, (snapshot) => {
+            const state = snapshot.value;
+            return state === 'dbInit' ||
+                state === 'saveConfig' ||
+                state === 'processSchemaFiles' ||
+                state === 'addModelsToStore' ||
+                state === 'addModelsToDb' ||
+                state === 'idle';
+        }, { timeout: 30000 });
+    }
+    return BaseDb.getAppDb();
+};
+const getExcludedTransactions = async () => {
+    const appDb = await getAppDbReady();
+    if (!appDb) {
+        return new Set();
+    }
+    const excludedTransactionsQuery = await appDb
+        .select()
+        .from(appState)
+        .where(eq(appState.key, 'excludedTransactions'));
+    const excludedTransactions = new Set();
+    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
+        const valueString = excludedTransactionsQuery[0].value;
+        if (valueString) {
+            const excludedTransactionsArray = JSON.parse(valueString);
+            for (const txId of excludedTransactionsArray) {
+                excludedTransactions.add(txId);
+            }
+        }
+    }
+    return excludedTransactions;
+};
+/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
+const ARWEAVE_TX_ID_RE$1 = /^[a-z0-9_-]{43}$/i;
+const normalizeArweaveTxId = (raw) => {
+    if (raw == null || raw === '')
+        return undefined;
+    const t = String(raw).trim();
+    if (ARWEAVE_TX_ID_RE$1.test(t))
+        return t;
+    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
+    if (m)
+        return m[1];
+    // Values may be full gateway URLs or paths; scan for the embedded tx id.
+    const embedded = t.match(/[a-z0-9_-]{43}/gi);
+    if (embedded) {
+        for (const candidate of embedded) {
+            if (ARWEAVE_TX_ID_RE$1.test(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+};
+const mergeAddressLists = (a, b) => {
+    const seen = new Set();
+    const out = [];
+    for (const addr of [...(a ?? []), ...(b ?? [])]) {
+        if (!addr || !addr.trim())
+            continue;
+        const k = addr.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(addr);
+    }
+    return out;
+};
+const collectTransactionIdsFromLocalMetadata = async () => {
+    const appDb = await getAppDbReady();
+    if (!appDb) {
+        return [];
+    }
+    const nameOr = or(eq(metadata.propertyName, 'storageTransactionId'), eq(metadata.propertyName, 'storage_transaction_id'), eq(metadata.propertyName, 'transactionId'));
+    const propRows = await appDb
+        .select({ propertyValue: metadata.propertyValue })
+        .from(metadata)
+        .where(and(nameOr, isNotNull(metadata.propertyValue)));
+    const refRows = await appDb
+        .select({ refResolvedValue: metadata.refResolvedValue })
+        .from(metadata)
+        .where(isNotNull(metadata.refResolvedValue));
+    const ids = new Set();
+    for (const row of propRows) {
+        const id = normalizeArweaveTxId(row.propertyValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    for (const row of refRows) {
+        const id = normalizeArweaveTxId(row.refResolvedValue ?? undefined);
+        if (id)
+            ids.add(id);
+    }
+    return Array.from(ids);
+};
+const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) => {
+    const transactionIds = [];
+    for (const fileMetadata of filesMetadata) {
+        // Validate and parse decodedDataJson
+        if (!fileMetadata.decodedDataJson || fileMetadata.decodedDataJson.trim() === '') {
+            console.warn('[events/files] [download] empty decodedDataJson for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        let json;
+        try {
+            json = JSON.parse(fileMetadata.decodedDataJson);
+        }
+        catch (error) {
+            console.warn('[events/files] [download] failed to parse decodedDataJson for fileMetadata: ', fileMetadata.id, error);
+            continue;
+        }
+        if (!Array.isArray(json) || json.length === 0 || !json[0]?.value?.value) {
+            console.warn('[events/files] [download] invalid decodedDataJson structure for fileMetadata: ', fileMetadata.id);
+            continue;
+        }
+        const rawTx = json[0].value.value;
+        if (typeof rawTx !== 'string' || rawTx.trim().length === 0) {
+            continue;
+        }
+        const transactionId = normalizeArweaveTxId(rawTx.trim());
+        if (!transactionId) {
+            continue;
+        }
+        if (excludedTransactions.has(transactionId) || excludedTransactions.has(rawTx.trim())) {
+            continue;
+        }
+        transactionIds.push(transactionId);
+    }
+    return transactionIds;
+};
+const downloadTransactionIds = async (rawTransactionIds, options) => {
+    if (!supportsOpfsFileDownloads()) {
+        return false;
+    }
+    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
+    if (transactionIds.length === 0) {
+        return false;
+    }
+    const excludedTransactions = await getExcludedTransactions();
+    const queryClient = BaseQueryClient.getQueryClient();
+    const transactionIdsToDownload = [];
+    await ensureReadGatewaySelected();
+    for (const transactionId of transactionIds) {
+        if (excludedTransactions.has(transactionId)) {
+            continue;
+        }
+        try {
+            // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
+            // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
+            let tags = [];
+            try {
+                tags = await queryClient.fetchQuery({
+                    queryKey: ['getTransactionTags', transactionId],
+                    queryFn: async () => BaseArweaveClient.getTransactionTags(transactionId),
+                });
+            }
+            catch {
+                tags = [];
+            }
+            if (tags && tags.length > 0) {
+                for (const { name, value } of tags) {
+                    if (name !== 'Content-SHA-256')
+                        continue;
+                    const metadataRecord = await getMetadata({
+                        storageTransactionId: transactionId,
+                    });
+                    if (metadataRecord) {
+                        await saveMetadata(metadataRecord, {
+                            contentHash: value,
+                        });
+                    }
+                }
+            }
+            transactionIdsToDownload.push(transactionId);
+        }
+        catch (error) {
+            logger$2(error);
+        }
+    }
+    if (transactionIdsToDownload.length === 0) {
+        return false;
+    }
+    // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
+    const arweaveBaseUrls = getArweaveReadBaseUrls();
+    if (transactionIdsToDownload.length === 1) {
+        await BaseFileManager.downloadFileByTransactionId({
+            transactionId: transactionIdsToDownload[0],
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
+            excludedTransactions,
+        });
+    }
+    else {
+        await BaseFileManager.downloadAllFiles({
+            transactionIds: transactionIdsToDownload,
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            arweaveBaseUrls,
+            excludedTransactions,
+        });
+    }
+    if (options?.resizeAllImages !== false) {
+        await BaseFileManager.resizeAllImages({
+            width: 480,
+            height: 480,
+        });
+    }
+    return true;
+};
+const runBulkDownloadWithDedupe = async (transactionIds) => {
+    if (bulkDownloadInFlight) {
+        return bulkDownloadInFlight;
+    }
+    bulkDownloadInFlight = (async () => {
+        try {
+            await downloadTransactionIds(transactionIds, { resizeAllImages: true });
+        }
+        finally {
+            bulkDownloadInFlight = null;
+        }
+    })();
+    return bulkDownloadInFlight;
+};
+const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    await syncDbFiles();
+    eventEmitter.emit('fs.downloadAll.success', { eventId });
+    eventEmitter.emit('fs.downloadAllBinary.request', { endpoints });
+};
+const downloadAllFilesBinaryRequestHandler = async (addressesHintOrPayload) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    const addressesHint = Array.isArray(addressesHintOrPayload)
+        ? addressesHintOrPayload
+        : undefined;
+    let fromDb = [];
+    if (BaseDb.isAppDbReady()) {
+        fromDb = await getAllAddressesFromDb();
+    }
+    if (!BaseDb.isAppDbReady()) {
+        await getAppDbReady();
+        fromDb = await getAllAddressesFromDb();
+    }
+    const addresses = mergeAddressLists(addressesHint, fromDb);
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
+    const queryClient = BaseQueryClient.getQueryClient();
+    const easClient = BaseEasClient.getEasClient();
+    const filesMetadataQueryKey = ['getFilesMetadata', ...addresses];
+    const fetchFilesMetadata = () => easClient.request(GET_FILES_METADATA, {
+        where: {
+            attester: {
+                in: addresses,
+            },
+            schema: {
+                is: {
+                    id: {
+                        equals: '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
+                    },
+                },
+            },
+        },
+    });
+    let { filesMetadata } = await queryClient.fetchQuery({
+        queryKey: filesMetadataQueryKey,
+        queryFn: fetchFilesMetadata,
+        staleTime: GET_FILES_METADATA_STALE_MS,
+    });
+    if ((!Array.isArray(filesMetadata) || filesMetadata.length === 0) && addresses.length > 0) {
+        await queryClient.removeQueries({ queryKey: filesMetadataQueryKey });
+        ({ filesMetadata } = await queryClient.fetchQuery({
+            queryKey: filesMetadataQueryKey,
+            queryFn: fetchFilesMetadata,
+            staleTime: GET_FILES_METADATA_STALE_MS,
+        }));
+    }
+    const filesRoot = BaseFileManager.getWorkingDir();
+    await BaseFileManager.createDirIfNotExists(filesRoot);
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    const excludedTransactions = await getExcludedTransactions();
+    const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
+    const fromLocal = await collectTransactionIdsFromLocalMetadata();
+    const transactionIds = Array.from(new Set([...fromEas, ...fromLocal]));
+    await runBulkDownloadWithDedupe(transactionIds);
+};
+const downloadTransactionIdWithDedupe = async (transactionId) => {
+    if (!supportsOpfsFileDownloads() || !transactionId || transactionId.trim().length === 0) {
+        return false;
+    }
+    const normalizedTxId = normalizeArweaveTxId(transactionId) ?? transactionId.trim();
+    const existing = lazyDownloadInFlightByTransactionId.get(normalizedTxId);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            const ok = await downloadTransactionIds([normalizedTxId], { resizeAllImages: false });
+            return ok;
+        }
+        finally {
+            lazyDownloadInFlightByTransactionId.delete(normalizedTxId);
+        }
+    })();
+    lazyDownloadInFlightByTransactionId.set(normalizedTxId, inFlight);
+    return inFlight;
+};
+const scheduleBulkFilesDownloadFromEasSyncThrottled = throttle((addressesHint) => {
+    void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
+        logger$2('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+    });
+}, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
+const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
+    if (!supportsOpfsFileDownloads()) {
+        return;
+    }
+    scheduleBulkFilesDownloadFromEasSyncThrottled(addressesHint);
+};
+
+var download = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    downloadAllFilesBinaryRequestHandler: downloadAllFilesBinaryRequestHandler,
+    downloadAllFilesRequestHandler: downloadAllFilesRequestHandler,
+    downloadTransactionIdWithDedupe: downloadTransactionIdWithDedupe,
+    scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
+});
+
+const logger$1 = debug('seedSdk:helpers:ensureImageLocal');
+/** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
+const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
+const IMAGE_SIZES = [
+    ImageSize.EXTRA_SMALL,
+    ImageSize.SMALL,
+    ImageSize.MEDIUM,
+    ImageSize.LARGE,
+    ImageSize.EXTRA_LARGE,
+];
+const inFlightByKey = new Map();
+const normalizeArweaveTxIdForEnsure = (raw) => {
+    if (raw == null || raw === '')
+        return undefined;
+    const t = String(raw).trim();
+    if (ARWEAVE_TX_ID_RE.test(t))
+        return t;
+    const m = t.match(/^([a-z0-9_-]{43})(?:\.[^/]+)?$/i);
+    if (m)
+        return m[1];
+    const embedded = t.match(/[a-z0-9_-]{43}/gi);
+    if (embedded) {
+        for (const candidate of embedded) {
+            if (ARWEAVE_TX_ID_RE.test(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+};
+const closestImageSize = (width) => {
+    let best = ImageSize.EXTRA_SMALL;
+    let bestDist = Math.abs(best - width);
+    for (const size of IMAGE_SIZES) {
+        const dist = Math.abs(size - width);
+        if (dist < bestDist) {
+            best = size;
+            bestDist = dist;
+        }
+    }
+    return best;
+};
+const mapRequestedWidthsToImageSizes = (widths) => {
+    const requested = widths && widths.length > 0 ? widths : [ImageSize.EXTRA_SMALL];
+    const unique = new Set();
+    for (const w of requested) {
+        if (typeof w !== 'number' || !Number.isFinite(w) || w <= 0)
+            continue;
+        unique.add(closestImageSize(w));
+    }
+    if (unique.size === 0) {
+        unique.add(ImageSize.EXTRA_SMALL);
+    }
+    return Array.from(unique).sort((a, b) => a - b);
+};
+const getBasename = (filePath) => {
+    const path = BaseFileManager.getPathModule();
+    return path.basename(filePath);
+};
+const getBasenameWithoutExtension = (fileName) => {
+    const match = fileName.match(/^(.*[\/\\])?([^\/\\]+?)(\.[^.\/\\]*)?$/);
+    return match?.[2] ?? fileName;
+};
+const resolveMatchingImagePath = async (needle) => {
+    const dirPath = BaseFileManager.getFilesPath('images');
+    const dirExists = await BaseFileManager.pathExists(dirPath);
+    if (!dirExists)
+        return undefined;
+    const fs = await BaseFileManager.getFs();
+    const path = BaseFileManager.getPathModule();
+    const files = await fs.promises.readdir(dirPath);
+    // Prefer exact basename match (files only); skip size dirs.
+    const exact = files.find((file) => path.basename(file) === needle);
+    if (exact) {
+        const candidate = BaseFileManager.getFilesPath('images', exact);
+        try {
+            const zenfs = await BaseFileManager.getFs();
+            const stat = await zenfs.promises.stat(candidate);
+            if (stat.isFile())
+                return candidate;
+        }
+        catch {
+            // fall through
+        }
+    }
+    const matchingFiles = files.filter((file) => {
+        const base = path.basename(file);
+        return base.includes(needle);
+    });
+    for (const file of matchingFiles) {
+        const candidate = BaseFileManager.getFilesPath('images', file);
+        try {
+            const zenfs = await BaseFileManager.getFs();
+            const stat = await zenfs.promises.stat(candidate);
+            if (stat.isFile())
+                return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+};
+const sizedVariantPath = (originalFilePath, size) => {
+    const path = BaseFileManager.getPathModule();
+    const dir = path.dirname(originalFilePath);
+    const base = getBasenameWithoutExtension(getBasename(originalFilePath));
+    return path.join(dir, String(size), `${base}.webp`);
+};
+const ensureKey = (txId, fileName, sizes) => {
+    const idPart = txId ?? fileName ?? '';
+    return `${idPart}|${sizes.join(',')}`;
+};
+const runEnsureImageLocal = async (params) => {
+    if (!supportsOpfsFileDownloads()) {
+        return { status: 'unsupported' };
+    }
+    const fileName = params.fileName?.trim() || undefined;
+    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
+        normalizeArweaveTxIdForEnsure(fileName);
+    if (!txId && !fileName) {
+        return { status: 'missing-id' };
+    }
+    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
+    const needles = [fileName, txId].filter((n) => typeof n === 'string' && n.length > 0);
+    try {
+        let filePath;
+        for (const needle of needles) {
+            filePath = await resolveMatchingImagePath(needle);
+            if (filePath)
+                break;
+        }
+        if (!filePath && txId) {
+            await downloadTransactionIdWithDedupe(txId);
+            for (const needle of needles) {
+                filePath = await resolveMatchingImagePath(needle);
+                if (filePath)
+                    break;
+            }
+            // Downloads store as bare tx id
+            if (!filePath) {
+                const direct = BaseFileManager.getFilesPath('images', txId);
+                if (await BaseFileManager.pathExists(direct)) {
+                    filePath = direct;
+                }
+            }
+        }
+        if (!filePath) {
+            return { status: 'failed' };
+        }
+        const createdWidths = [];
+        for (const size of targetSizes) {
+            const variantPath = sizedVariantPath(filePath, size);
+            const exists = await BaseFileManager.pathExists(variantPath);
+            if (exists)
+                continue;
+            await BaseFileManager.resizeImage({
+                filePath,
+                width: size,
+                height: size,
+            });
+            createdWidths.push(size);
+        }
+        return {
+            status: 'ready',
+            filePath,
+            createdWidths,
+        };
+    }
+    catch (error) {
+        logger$1('ensureImageLocal failed', error);
+        return { status: 'failed' };
+    }
+};
+/**
+ * Ensure an image original exists in OPFS (downloading from Arweave if needed)
+ * and create only the requested ImageSize variant(s) for that one file.
+ */
+const ensureImageLocal = async (params) => {
+    if (!supportsOpfsFileDownloads()) {
+        return { status: 'unsupported' };
+    }
+    const fileName = params.fileName?.trim() || undefined;
+    const txId = normalizeArweaveTxIdForEnsure(params.transactionId) ??
+        normalizeArweaveTxIdForEnsure(fileName);
+    if (!txId && !fileName) {
+        return { status: 'missing-id' };
+    }
+    const targetSizes = mapRequestedWidthsToImageSizes(params.widths);
+    const key = ensureKey(txId, fileName, targetSizes);
+    const existing = inFlightByKey.get(key);
+    if (existing) {
+        return existing;
+    }
+    const inFlight = (async () => {
+        try {
+            return await runEnsureImageLocal({
+                transactionId: txId,
+                fileName,
+                widths: targetSizes,
+            });
+        }
+        finally {
+            inFlightByKey.delete(key);
+        }
+    })();
+    inFlightByKey.set(key, inFlight);
+    return inFlight;
+};
+
+const logger = debug('seedSdk:shared:helpers');
+const toSnakeCase = (str) => {
+    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+};
+const getMimeType = (base64) => {
+    if (!base64) {
+        return null;
+    }
+    const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
+    if (result && result.length > 1) {
+        return result[1];
+    }
+    else {
+        return null; // MIME type could not be determined
+    }
+};
+const getCorrectId = (localIdOrUid) => {
+    const id = {
+        localId: undefined,
+        uid: undefined,
+    };
+    if (!localIdOrUid) {
+        return id;
+    }
+    if (localIdOrUid.length === 10) {
+        id.localId = localIdOrUid;
+    }
+    if (localIdOrUid.startsWith('0x') && localIdOrUid.length === 66) {
+        id.uid = localIdOrUid;
+    }
+    return id;
+};
+const getDataTypeFromString = (data) => {
+    const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
+    if (nonImageBase64Regex.test(data)) {
+        return 'base64';
+    }
+    // Regular expression for base64 (simple version, checking for base64 format)
+    const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
+    if (imageBase64Regex.test(data)) {
+        return 'imageBase64';
+    }
+    // Blob URLs are fetchable but session-scoped; recognize them as url type
+    if (data.startsWith('blob:')) {
+        return 'url';
+    }
+    // Regular expression for URL (simple version, checking for common URL format)
+    const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
+    if (urlRegex.test(data)) {
+        return 'url';
+    }
+    return null;
+};
+const convertTxIdToImage = async (txId) => {
+    const imageFilePath = BaseFileManager.getFilesPath('images', txId);
+    const fileExists = await BaseFileManager.pathExists(imageFilePath);
+    if (!fileExists) {
+        logger(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
+        return;
+    }
+    const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
+    // Convert Blob to ArrayBuffer if needed, or use Buffer directly
+    let arrayBuffer;
+    if (buffer instanceof Blob) {
+        arrayBuffer = await buffer.arrayBuffer();
+    }
+    else if (buffer instanceof ArrayBuffer) {
+        arrayBuffer = buffer;
+    }
+    else {
+        // Node.js Buffer
+        const sliced = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        // Handle SharedArrayBuffer case by creating a new ArrayBuffer
+        if (sliced instanceof SharedArrayBuffer) {
+            const uint8Array = new Uint8Array(sliced);
+            arrayBuffer = uint8Array.buffer.slice(0);
+        }
+        else {
+            arrayBuffer = sliced;
+        }
+    }
+    const uint = new Uint8Array(arrayBuffer);
+    const imageBlob = new Blob([uint]);
+    return URL.createObjectURL(imageBlob);
+};
+/**
+ * Constructs an Arweave URL for a storage transaction ID
+ * @param storageTransactionId - The Arweave transaction ID
+ * @returns The full URL to access the transaction data on Arweave (e.g., https://arweave.net/raw/{transactionId})
+ * @deprecated Use BaseArweaveClient.getRawUrl() instead for better consistency and testability
+ */
+const getArweaveUrlForTransaction = (storageTransactionId) => {
+    return BaseArweaveClient.getRawUrl(storageTransactionId);
+};
+
+export { isStorageSeedRef as a, getArweaveUrlForTransaction as b, classifyMediaRef as c, closestImageSize as d, eventEmitter as e, ensureImageLocal as f, getCorrectId as g, getFeedItemStringField as h, isPublishedSeedRef as i, normalizeArweaveTxIdForEnsure as j, normalizeFeedItemFields as k, resolveMediaRef as l, getStorageTransactionIdForSeedUid as m, normalizeRelationPropertyValue as n, convertTxIdToImage as o, downloadTransactionIdWithDedupe as p, getDataTypeFromString as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, getMimeType as u, isNode as v, isBrowser as w, downloadAllFilesRequestHandler as x, downloadAllFilesBinaryRequestHandler as y, download as z };
+//# sourceMappingURL=index-280bL-n4.js.map