@seedprotocol/sdk 0.6.5 → 0.6.7

package/dist/constants-DSqHBPNe.js

@@ -0,0 +1,1347 @@
+import debug from 'debug';
+import { a as BaseDb, b as metadata, B as BaseFileManager, c as appState, C as ImageSize } from './BasePathResolver-qV0apdVY.js';
+import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected } from '@seedprotocol/arweave';
+import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
+import { waitFor } from 'xstate';
+import 'pluralize';
+import { Type } from '@sinclair/typebox';
+import { and, eq, or, isNotNull } from 'drizzle-orm';
+import { a as getAllAddressesFromDb } from './db-CceyWksv.js';
+import 'nanoid';
+import 'nanoid-dictionary';
+import '@seedprotocol/query';
+import { throttle } from 'lodash-es';
+
+/** Default maximum length for Text properties when not explicitly set. Html holds arbitrary-length content and does not use this limit. */
+const DEFAULT_TEXT_MAX_LENGTH = 255;
+/**
+ * TypeBox schema for ValidationRules
+ */
+const TValidationRules = Type.Object({
+    pattern: Type.Optional(Type.String()),
+    minLength: Type.Optional(Type.Integer({ minimum: 0 })),
+    maxLength: Type.Optional(Type.Integer({ minimum: 1 })),
+    enum: Type.Optional(Type.Array(Type.Any())),
+    custom: Type.Optional(Type.String()),
+}, { additionalProperties: true });
+
+/**
+ * Enum for all property data types
+ */
+var ModelPropertyDataTypes;
+(function (ModelPropertyDataTypes) {
+    ModelPropertyDataTypes["Text"] = "Text";
+    ModelPropertyDataTypes["Number"] = "Number";
+    ModelPropertyDataTypes["List"] = "List";
+    ModelPropertyDataTypes["Relation"] = "Relation";
+    ModelPropertyDataTypes["Image"] = "Image";
+    ModelPropertyDataTypes["Json"] = "Json";
+    ModelPropertyDataTypes["File"] = "File";
+    ModelPropertyDataTypes["Boolean"] = "Boolean";
+    ModelPropertyDataTypes["Date"] = "Date";
+    ModelPropertyDataTypes["Html"] = "Html";
+})(ModelPropertyDataTypes || (ModelPropertyDataTypes = {}));
+/** Known data types in lowercase for normalization */
+const DATA_TYPE_LOWER_MAP = {
+    text: 'Text',
+    string: 'Text', // JSON Schema convention
+    number: 'Number',
+    list: 'List',
+    relation: 'Relation',
+    image: 'Image',
+    json: 'Json',
+    file: 'File',
+    boolean: 'Boolean',
+    date: 'Date',
+    html: 'Html',
+    blob: 'Blob',
+};
+/**
+ * Normalize dataType to canonical PascalCase form.
+ * Accepts lowercase (e.g. 'text') or mixed case and returns 'Text'.
+ * Use when ingesting dataType from JSON schema files.
+ */
+function normalizeDataType(value) {
+    if (!value || typeof value !== 'string')
+        return value ?? '';
+    const lower = value.toLowerCase().trim();
+    return DATA_TYPE_LOWER_MAP[lower] ?? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+}
+const TPropertyDataType = Type.Union([
+    Type.Literal(ModelPropertyDataTypes.Text),
+    Type.Literal(ModelPropertyDataTypes.Number),
+    Type.Literal(ModelPropertyDataTypes.List),
+    Type.Literal(ModelPropertyDataTypes.Relation),
+    Type.Literal(ModelPropertyDataTypes.Image),
+    Type.Literal(ModelPropertyDataTypes.Json),
+    Type.Literal(ModelPropertyDataTypes.File),
+    Type.Literal(ModelPropertyDataTypes.Boolean),
+    Type.Literal(ModelPropertyDataTypes.Date),
+    Type.Literal(ModelPropertyDataTypes.Html),
+]);
+const TStorageType = Type.Union([
+    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
+    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
+]);
+/** How publish handles `data:image/*` URIs inside Html storage. Only applies when `dataType === 'Html'`. */
+const THtmlEmbeddedDataUriPolicy = Type.Union([
+    Type.Literal('materialize'),
+    Type.Literal('preserve'),
+]);
+const TProperty = Type.Object({
+    id: Type.Optional(Type.String()), // schemaFileId (string) - public ID
+    _dbId: Type.Optional(Type.Number()), // Database integer ID - internal only
+    name: Type.Optional(Type.String()),
+    dataType: TPropertyDataType,
+    ref: Type.Optional(Type.String()),
+    // modelId: string (modelFileId) in code; number only for DB foreign keys when resolved
+    modelId: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    modelName: Type.Optional(Type.String()),
+    refModelId: Type.Optional(Type.Number()),
+    refModelName: Type.Optional(Type.String()),
+    refValueType: Type.Optional(TPropertyDataType),
+    storageType: Type.Optional(TStorageType),
+    localStorageDir: Type.Optional(Type.String()),
+    filenameSuffix: Type.Optional(Type.String()),
+    validation: Type.Optional(TValidationRules),
+    required: Type.Optional(Type.Boolean()),
+    /** When set on an Html property: `materialize` uploads embedded images as Image seeds and rewrites src; `preserve` leaves data URIs. */
+    htmlEmbeddedDataUriPolicy: Type.Optional(THtmlEmbeddedDataUriPolicy),
+});
+const TPropertyConstructor = Type.Function([
+    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
+    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
+    Type.Optional(Type.Union([Type.String(), Type.Boolean()])),
+], TProperty);
+const TPropertyDefs = Type.Record(TPropertyDataType, TPropertyConstructor);
+function htmlPropertyFactory(opts) {
+    return {
+        dataType: ModelPropertyDataTypes.Html,
+        ...(opts?.htmlEmbeddedDataUriPolicy
+            ? { htmlEmbeddedDataUriPolicy: opts.htmlEmbeddedDataUriPolicy }
+            : {}),
+    };
+}
+const Property = {
+    Text: (storageType, localStorageDir, filenameSuffix) => ({
+        dataType: ModelPropertyDataTypes.Text,
+        storageType,
+        localStorageDir,
+        filenameSuffix,
+        TObject: Type.String(),
+    }),
+    Json: () => ({ dataType: ModelPropertyDataTypes.Json }),
+    File: () => ({ dataType: ModelPropertyDataTypes.File }),
+    Number: () => ({ dataType: ModelPropertyDataTypes.Number }),
+    /**
+     * Create a List property. refValueType is required; ref is required only for list of relations.
+     * @param refValueType - Element type: 'Text', 'Number', 'Relation', etc.
+     * @param ref - Model name when refValueType is 'Relation' (optional for primitives)
+     * @example List('Text') - list of strings
+     * @example List('Relation', 'Tag') - list of relations to Tag model
+     */
+    List: (refValueType, ref) => ({
+        dataType: ModelPropertyDataTypes.List,
+        ref,
+        refValueType,
+    }),
+    Relation: (ref, refValueType, required) => ({
+        dataType: ModelPropertyDataTypes.Relation,
+        ref,
+        refValueType,
+        required,
+    }),
+    Image: () => ({ dataType: ModelPropertyDataTypes.Image }),
+    Boolean: () => ({ dataType: ModelPropertyDataTypes.Boolean }),
+    Date: () => ({ dataType: ModelPropertyDataTypes.Date }),
+    Html: htmlPropertyFactory,
+    /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
+};
+const PropertyMetadataKey = Symbol('property');
+const PropertyConstructor = (propertyType) => {
+    return function (parentClassPrototype, propertyKey) {
+        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
+        existingProperties.push({ propertyKey, propertyType });
+        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
+    };
+};
+const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
+const Number$1 = () => PropertyConstructor(Property.Number());
+const Json = () => PropertyConstructor(Property.Json());
+const File = () => PropertyConstructor(Property.File());
+const Image = () => PropertyConstructor(Property.Image());
+const Relation = (ref, refValueType, required) => PropertyConstructor(Property.Relation(ref, refValueType, required)); // Adjust for actual relation type
+const List = (refValueType, ref) => PropertyConstructor(Property.List(refValueType, ref));
+const Boolean = () => PropertyConstructor(Property.Boolean());
+const Date$1 = () => PropertyConstructor(Property.Date());
+const Html = (opts) => PropertyConstructor(htmlPropertyFactory(opts));
+
+/** 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 {};
+}
+
+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-Y5EWQuJj.js');
+        const _ns_0 = _mod_0.ai;
+        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;
+    }
+    if (transactionIdsToDownload.length === 1) {
+        await BaseFileManager.downloadFileByTransactionId({
+            transactionId: transactionIdsToDownload[0],
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            excludedTransactions,
+        });
+    }
+    else {
+        await BaseFileManager.downloadAllFiles({
+            transactionIds: transactionIdsToDownload,
+            arweaveHost: BaseArweaveClient.getBaseUrl(),
+            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);
+};
+
+const ENV = (typeof process !== 'undefined' && process.env)
+    ? process.env
+    : (typeof window !== 'undefined' && window.env)
+        ? window.env
+        : {};
+var MachineIds;
+(function (MachineIds) {
+    MachineIds["CLIENT_MANAGER"] = "@seedSdk/clientManager";
+    MachineIds["EAS_SYNC_MANAGER"] = "@seedSdk/easSyncManager";
+    MachineIds["GLOBAL"] = "@seedSdk/global";
+    MachineIds["INTERNAL"] = "@seedSdk/internal";
+    MachineIds["EAS"] = "@seedSdk/eas";
+    MachineIds["ITEM"] = "@seedSdk/item";
+    MachineIds["ALL_ITEMS"] = "@seedSdk/allItems";
+    MachineIds["MODEL"] = "@seedSdk/model";
+    MachineIds["FILE_SYSTEM"] = "@seedSdk/fileSystem";
+})(MachineIds || (MachineIds = {}));
+const { INTERNAL, GLOBAL, EAS, MODEL } = MachineIds;
+var ClientManagerState;
+(function (ClientManagerState) {
+    ClientManagerState["UNINITIALIZED"] = "uninitialized";
+    ClientManagerState["PLATFORM_CLASSES_INIT"] = "platformClassesInit";
+    ClientManagerState["FILE_SYSTEM_INIT"] = "fileSystemInit";
+    ClientManagerState["DB_INIT"] = "dbInit";
+    ClientManagerState["SAVE_CONFIG"] = "saveConfig";
+    ClientManagerState["ADD_MODELS_TO_STORE"] = "addModelsToStore";
+    ClientManagerState["ADD_MODELS_TO_DB"] = "addModelsToDb";
+    ClientManagerState["PROCESS_SCHEMA_FILES"] = "processSchemaFiles";
+    ClientManagerState["IDLE"] = "idle";
+    ClientManagerState["INIT_FAILED"] = "initFailed";
+})(ClientManagerState || (ClientManagerState = {}));
+var ClientManagerEvents;
+(function (ClientManagerEvents) {
+    ClientManagerEvents["UPDATE_CONTEXT"] = "updateContext";
+    ClientManagerEvents["PLATFORM_CLASSES_READY"] = "platformClassesReady";
+    ClientManagerEvents["FILE_SYSTEM_READY"] = "fileSystemReady";
+    ClientManagerEvents["DB_READY"] = "dbReady";
+    ClientManagerEvents["SAVE_CONFIG_SUCCESS"] = "saveConfigSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_SUCCESS"] = "saveAppStateSuccess";
+    ClientManagerEvents["SAVE_APP_STATE_ERROR"] = "saveAppStateError";
+    ClientManagerEvents["SET_ADDRESSES"] = "setAddresses";
+    ClientManagerEvents["ADD_MODELS_TO_STORE_SUCCESS"] = "addModelsToStoreSuccess";
+    ClientManagerEvents["ADD_MODELS_TO_DB_SUCCESS"] = "addModelsToDbSuccess";
+    ClientManagerEvents["PROCESS_SCHEMA_FILES_SUCCESS"] = "processSchemaFilesSuccess";
+})(ClientManagerEvents || (ClientManagerEvents = {}));
+var GlobalState;
+(function (GlobalState) {
+    GlobalState["UNINITIALIZED"] = "uninitialized";
+    GlobalState["INITIALIZING"] = "initializing";
+    GlobalState["INITIALIZED"] = "initialized";
+    GlobalState["PUBLISHING_ITEM"] = "publishingItem";
+    GlobalState["ADDING_MODELS_TO_DB"] = "addingModelsToDb";
+})(GlobalState || (GlobalState = {}));
+const { UNINITIALIZED: GLOBAL_UNINITIALIZED, INITIALIZING, INITIALIZED, PUBLISHING_ITEM, ADDING_MODELS_TO_DB, } = GlobalState;
+var InternalState;
+(function (InternalState) {
+    InternalState["IDLE"] = "idle";
+    InternalState["INITIALIZING"] = "initializing";
+    InternalState["VALIDATING_INPUT"] = "validatingInput";
+    InternalState["CONFIGURING_FS"] = "configuringFs";
+    InternalState["LOADING_SEED_DB"] = "loadingSeedDb";
+    InternalState["SAVING_CONFIG"] = "savingConfig";
+    InternalState["LOADING_APP_DB"] = "loadingAppDb";
+    InternalState["LOADING_SDK_DB"] = "loadingSdkDb";
+})(InternalState || (InternalState = {}));
+const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } = InternalState;
+var PublishMachineStates;
+(function (PublishMachineStates) {
+    PublishMachineStates["VALIDATING_ITEM_DATA"] = "validatingItemData";
+    PublishMachineStates["CREATING_PUBLISH_ATTEMPT"] = "creatingPublishAttempt";
+    PublishMachineStates["UPLOADING"] = "uploading";
+    PublishMachineStates["PREPARING_PUBLISH_REQUEST_DATA"] = "preparingPublishRequestData";
+    PublishMachineStates["PUBLISHING"] = "publishing";
+    PublishMachineStates["IDLE"] = "idle";
+})(PublishMachineStates || (PublishMachineStates = {}));
+const EAS_ENDPOINT = ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
+    ENV.EAS_ENDPOINT ||
+    'https://optimism-sepolia.easscan.org/graphql';
+/**
+ * @deprecated Use BaseArweaveClient.getHost() instead.
+ * This constant is kept for backward compatibility but will be removed in a future version.
+ * Migration: import { BaseArweaveClient } from '@/helpers' and use BaseArweaveClient.getHost()
+ */
+ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'ar.seedprotocol.io';
+
+export { getStorageTransactionIdForSeedUid as A, Boolean as B, ClientManagerState as C, DEFAULT_TEXT_MAX_LENGTH as D, EAS_ENDPOINT as E, File as F, convertTxIdToImage as G, Html as H, Image as I, Json as J, downloadTransactionIdWithDedupe as K, List as L, ModelPropertyDataTypes as M, Number$1 as N, getDataTypeFromString as O, Property as P, getMimeType as Q, Relation as R, isBrowser as S, THtmlEmbeddedDataUriPolicy as T, isNode as U, downloadAllFilesRequestHandler as V, downloadAllFilesBinaryRequestHandler as W, ClientManagerEvents as X, download as Y, Date$1 as a, PropertyConstructor as b, PropertyMetadataKey as c, TProperty as d, TPropertyConstructor as e, TPropertyDataType as f, TPropertyDefs as g, TStorageType as h, TValidationRules as i, Text as j, normalizeRelationPropertyValue as k, getCorrectId as l, eventEmitter as m, normalizeDataType as n, getArweaveUrlForTransaction as o, MachineIds as p, classifyMediaRef as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, closestImageSize as u, ensureImageLocal as v, getFeedItemStringField as w, normalizeArweaveTxIdForEnsure as x, normalizeFeedItemFields as y, resolveMediaRef as z };
+//# sourceMappingURL=constants-DSqHBPNe.js.map