@seedprotocol/sdk 0.4.32 → 0.5.1

package/dist/constants-B5S5JPDK.js

@@ -0,0 +1,660 @@
+import debug from 'debug';
+import { B as BaseDb, f as metadata, a as BaseFileManager } from './BasePathResolver-BDgc7c4T.js';
+import { BaseArweaveClient } from '@seedprotocol/arweave';
+import '@seedprotocol/eas';
+import 'xstate';
+import 'pluralize';
+import { Type } from '@sinclair/typebox';
+import { and, eq } from 'drizzle-orm';
+import 'nanoid';
+import 'nanoid-dictionary';
+
+/** 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 = () => 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$1 = 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:')) {
+        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$1(`[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 '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;
+}
+
+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 parseEasRelationPropertyName = (easPropertyName) => {
+    // Split the input string on the first underscore
+    const [singularProperty, modelName, idSegment] = easPropertyName.split('_');
+    // If there are any other parts, assume it is a list (e.g., has 'ids' or other suffix)
+    const isList = idSegment === 'ids';
+    // Create the final property name by pluralizing the singular part
+    const propertyName = singularProperty.endsWith('s')
+        ? singularProperty
+        : singularProperty + 's';
+    return {
+        propertyName, // Plural form of the property name
+        modelName, // Model name extracted from the second part
+        isList, // True if the property is a list (e.g., 'ids' is present)
+    };
+};
+
+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 || (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["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 { ClientManagerEvents as A, Boolean as B, ClientManagerState as C, Date$1 as D, EAS_ENDPOINT as E, File as F, Html as H, Image as I, Json as J, List as L, ModelPropertyDataTypes as M, Number as N, Property as P, Relation as R, TPropertyDataType as T, TStorageType as a, THtmlEmbeddedDataUriPolicy as b, TProperty as c, TPropertyConstructor as d, TPropertyDefs as e, PropertyMetadataKey as f, PropertyConstructor as g, Text as h, DEFAULT_TEXT_MAX_LENGTH as i, TValidationRules as j, normalizeRelationPropertyValue as k, getCorrectId as l, getArweaveUrlForTransaction as m, normalizeDataType as n, MachineIds as o, parseEasRelationPropertyName as p, classifyMediaRef as q, resolveSeedIdsFromRefString as r, resolveMediaRef as s, toSnakeCase as t, normalizeFeedItemFields as u, getFeedItemStringField as v, getStorageTransactionIdForSeedUid as w, convertTxIdToImage as x, getDataTypeFromString as y, getMimeType as z };
+//# sourceMappingURL=constants-B5S5JPDK.js.map