@campnetwork/origin 1.4.0-alpha.4 → 1.4.0-alpha.6

package/dist/react/index.esm.js

@@ -6599,6 +6599,7 @@ var constants = {
     SUPPORTED_VIDEO_FORMATS: ["video/mp4", "video/webm"],
     SUPPORTED_AUDIO_FORMATS: ["audio/mpeg", "audio/wav", "audio/ogg"],
     SUPPORTED_TEXT_FORMATS: ["text/plain"],
+    MAX_FILE_SIZE: 20 * 1024 * 1024, // 20 MB
     AVAILABLE_SOCIALS: ["twitter", "spotify"], // tiktok disabled
     MAX_LICENSE_DURATION: 2628000, // 30 days in seconds
     MIN_LICENSE_DURATION: 86400, // 1 day in seconds
@@ -8412,7 +8413,7 @@ function bulkBuyAccessSmart(tokenIds, options) {
  *     creatorContentHash: "0x...",
  *     uri: "ipfs://...",
  *     licenseTerms: { price: 1000n, duration: 86400, royaltyBps: 500, paymentToken: zeroAddress, licenseType: 0 },
- *     deadline: BigInt(Date.now() + 600000),
+ *     deadline: BigInt(Math.floor(Date.now() / 1000) + 600),
  *     parents: [],
  *     isIP: true,
  *     appId: "myApp",
@@ -8443,6 +8444,312 @@ function bulkMintTolerant(mints) {
     return this.callContractMethod(this.environment.BATCH_OPERATIONS_CONTRACT_ADDRESS, this.environment.BATCH_OPERATIONS_ABI, "bulkMintTolerant", [mints], { waitForReceipt: true });
 }
 
+function validateIpfsCredentials(credentials) {
+    switch (credentials.provider) {
+        case "pinata":
+            if (!credentials.jwt && !(credentials.apiKey && credentials.apiSecret)) {
+                throw new ValidationError("Pinata requires either 'jwt' or both 'apiKey' and 'apiSecret'");
+            }
+            break;
+        case "infura":
+            if (!credentials.projectId || !credentials.projectSecret) {
+                throw new ValidationError("Infura requires both 'projectId' and 'projectSecret'");
+            }
+            break;
+        case "web3storage":
+            if (!credentials.token) {
+                throw new ValidationError("web3.storage requires 'token'");
+            }
+            break;
+        default:
+            throw new ValidationError(`Unsupported IPFS provider: ${credentials.provider}`);
+    }
+}
+/**
+ * Save IPFS credentials for large file uploads.
+ * Users can configure their own IPFS pinning service (Pinata, Infura, or web3.storage).
+ * @param credentials The IPFS credentials to save.
+ * @throws {APIError} If saving credentials fails.
+ * @example
+ * ```typescript
+ * // Save Pinata credentials
+ * await origin.saveIpfsCredentials({
+ *   provider: 'pinata',
+ *   jwt: 'your-pinata-jwt-token'
+ * });
+ *
+ * // Save Infura credentials
+ * await origin.saveIpfsCredentials({
+ *   provider: 'infura',
+ *   projectId: 'your-project-id',
+ *   projectSecret: 'your-project-secret'
+ * });
+ * ```
+ */
+function saveIpfsCredentials(credentials) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        // Validate credentials before sending
+        validateIpfsCredentials(credentials);
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(credentials),
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to save IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+    });
+}
+/**
+ * Verify that saved IPFS credentials are valid.
+ * @returns Object with valid boolean and optional error message.
+ * @throws {APIError} If verification request fails.
+ */
+function verifyIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials/verify`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 404) {
+                return { valid: false, error: "No IPFS credentials configured" };
+            }
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to verify IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+        const result = yield response.json();
+        return result.data;
+    });
+}
+/**
+ * Delete saved IPFS credentials.
+ * @throws {APIError} If deletion fails.
+ */
+function deleteIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS credentials management");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+            },
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to delete IPFS credentials (HTTP ${response.status})`, response.status);
+        }
+    });
+}
+/**
+ * Check if user has IPFS credentials configured.
+ * @returns True if credentials are configured, false otherwise.
+ */
+function hasIpfsCredentials() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!this.jwt) {
+            return false;
+        }
+        try {
+            const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/credentials`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.jwt}`,
+                },
+            });
+            if (!response.ok) {
+                return false;
+            }
+            const data = yield response.json();
+            return ((_a = data.data) === null || _a === void 0 ? void 0 : _a.hasCredentials) || false;
+        }
+        catch (_b) {
+            return false;
+        }
+    });
+}
+/**
+ * Get IPFS upload config for client-side uploads.
+ * @returns IPFS config or null if not configured.
+ */
+function getIpfsUploadConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            return null;
+        }
+        try {
+            const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/upload-config`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.jwt}`,
+                },
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const result = yield response.json();
+            return result.data || null;
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+/**
+ * Upload a file to user's IPFS pinning service.
+ * @param file The file to upload.
+ * @param config The IPFS upload config.
+ * @param progressCallback Optional progress callback with intermediate upload progress.
+ * @returns The IPFS CID of the uploaded file.
+ */
+function uploadToUserIPFS(file, config, progressCallback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        // Validate file input
+        if (!file || !(file instanceof File)) {
+            throw new ValidationError("Invalid file: must be a File object");
+        }
+        if (file.size === 0) {
+            throw new ValidationError("Cannot upload empty file");
+        }
+        progressCallback === null || progressCallback === void 0 ? void 0 : progressCallback(0);
+        const onUploadProgress = progressCallback
+            ? (progressEvent) => {
+                if (progressEvent.total) {
+                    const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+                    progressCallback(percent);
+                }
+            }
+            : undefined;
+        let cid;
+        switch (config.provider) {
+            case "pinata": {
+                const formData = new FormData();
+                formData.append("file", file);
+                const headers = {};
+                if ((_a = config.pinata) === null || _a === void 0 ? void 0 : _a.jwt) {
+                    headers["Authorization"] = `Bearer ${config.pinata.jwt}`;
+                }
+                else if (((_b = config.pinata) === null || _b === void 0 ? void 0 : _b.apiKey) && ((_c = config.pinata) === null || _c === void 0 ? void 0 : _c.apiSecret)) {
+                    headers["pinata_api_key"] = config.pinata.apiKey;
+                    headers["pinata_secret_api_key"] = config.pinata.apiSecret;
+                }
+                try {
+                    const response = yield axios.post("https://api.pinata.cloud/pinning/pinFileToIPFS", formData, { headers, onUploadProgress, timeout: 600000 });
+                    cid = response.data.IpfsHash;
+                }
+                catch (error) {
+                    const status = (_d = error.response) === null || _d === void 0 ? void 0 : _d.status;
+                    const message = ((_g = (_f = (_e = error.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.error) === null || _g === void 0 ? void 0 : _g.details) ||
+                        ((_j = (_h = error.response) === null || _h === void 0 ? void 0 : _h.data) === null || _j === void 0 ? void 0 : _j.message) ||
+                        error.message;
+                    throw new APIError(`Pinata IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            case "infura": {
+                if (!config.infura) {
+                    throw new Error("Infura config missing");
+                }
+                const formData = new FormData();
+                formData.append("file", file);
+                const auth = btoa(`${config.infura.projectId}:${config.infura.projectSecret}`);
+                try {
+                    const response = yield axios.post(`${config.infura.endpoint}/api/v0/add`, formData, {
+                        headers: { Authorization: `Basic ${auth}` },
+                        onUploadProgress,
+                        timeout: 600000,
+                    });
+                    cid = response.data.Hash;
+                }
+                catch (error) {
+                    const status = (_k = error.response) === null || _k === void 0 ? void 0 : _k.status;
+                    const message = ((_m = (_l = error.response) === null || _l === void 0 ? void 0 : _l.data) === null || _m === void 0 ? void 0 : _m.Message) || error.message;
+                    throw new APIError(`Infura IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            case "web3storage": {
+                if (!((_o = config.web3storage) === null || _o === void 0 ? void 0 : _o.token)) {
+                    throw new Error("web3.storage config missing");
+                }
+                try {
+                    const response = yield axios.post("https://api.web3.storage/upload", file, {
+                        headers: {
+                            Authorization: `Bearer ${config.web3storage.token}`,
+                            "X-Name": file.name,
+                        },
+                        onUploadProgress,
+                        timeout: 600000,
+                    });
+                    cid = response.data.cid;
+                }
+                catch (error) {
+                    const status = (_p = error.response) === null || _p === void 0 ? void 0 : _p.status;
+                    const message = ((_r = (_q = error.response) === null || _q === void 0 ? void 0 : _q.data) === null || _r === void 0 ? void 0 : _r.message) || error.message;
+                    throw new APIError(`web3.storage IPFS upload failed: ${message}`, status);
+                }
+                break;
+            }
+            default:
+                throw new ValidationError(`Unsupported IPFS provider: ${config.provider}. Supported providers: pinata, infura, web3storage`);
+        }
+        if (!cid || typeof cid !== "string") {
+            throw new APIError(`IPFS upload to ${config.provider} succeeded but returned no CID`);
+        }
+        progressCallback === null || progressCallback === void 0 ? void 0 : progressCallback(100);
+        return cid;
+    });
+}
+/**
+ * Register an IPFS file with the backend after client-side upload.
+ * @param cid The IPFS CID of the uploaded file.
+ * @param fileName The original file name.
+ * @param fileType The file MIME type.
+ * @returns The registered file key.
+ */
+function registerIpfsFile(cid, fileName, fileType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this.jwt) {
+            throw new APIError("JWT token required for IPFS file registration");
+        }
+        const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/ipfs/register-file`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ cid, fileName, fileType }),
+        });
+        if (!response.ok) {
+            const errorData = yield response.json().catch(() => ({}));
+            throw new APIError(errorData.message ||
+                `Failed to register IPFS file (HTTP ${response.status})`, response.status);
+        }
+        const result = yield response.json();
+        return { fileKey: result.data.fileKey };
+    });
+}
+
 var _Origin_instances, _Origin_generateURL, _Origin_setOriginStatus, _Origin_uploadToIPFS, _Origin_uploadFile, _Origin_waitForTxReceipt, _Origin_ensureChainId, _Origin_getCurrentAccount, _Origin_getProtocolFeeBps, _Origin_getAppFeeBpsForToken, _Origin_resolveWalletAddress;
 /**
  * The Origin class
@@ -8516,6 +8823,14 @@ class Origin {
         this.getRoyaltyTokenBalance = getRoyaltyTokenBalance.bind(this);
         // AppRegistry module methods
         this.getAppInfo = getAppInfo.bind(this);
+        // IPFS credentials methods
+        this.saveIpfsCredentials = saveIpfsCredentials.bind(this);
+        this.verifyIpfsCredentials = verifyIpfsCredentials.bind(this);
+        this.deleteIpfsCredentials = deleteIpfsCredentials.bind(this);
+        this.hasIpfsCredentials = hasIpfsCredentials.bind(this);
+        this.getIpfsUploadConfig = getIpfsUploadConfig.bind(this);
+        this.uploadToUserIPFS = uploadToUserIPFS.bind(this);
+        this.registerIpfsFile = registerIpfsFile.bind(this);
     }
     getJwt() {
         return this.jwt;
@@ -8569,7 +8884,7 @@ class Origin {
      * @param metadata The metadata associated with the file.
      * @param license The license terms for the IpNFT.
      * @param parents Optional parent token IDs for lineage tracking.
-     * @param options Optional parameters including progress callback, preview image, and use asset as preview flag.
+     * @param options Optional parameters including progress callback, preview image, use asset as preview flag, and forceIpfs.
      * @returns The token ID of the minted IpNFT as a string, or null if minting failed.
      */
     mintFile(file, metadata, license, parents, options) {
@@ -8581,17 +8896,37 @@ class Origin {
             catch (error) {
                 throw new WalletError(`Cannot mint file "${file.name}": wallet not connected. Please connect a wallet first.`);
             }
+            // Check if we should use IPFS for this file
+            const shouldUseIpfs = (options === null || options === void 0 ? void 0 : options.forceIpfs) || file.size > constants.MAX_FILE_SIZE;
             let info;
-            try {
-                info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, options);
-                if (!info || !info.key) {
-                    throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+            if (shouldUseIpfs) {
+                // Large file - use user's IPFS pinning service
+                const ipfsConfig = yield this.getIpfsUploadConfig();
+                if (!ipfsConfig) {
+                    throw new APIError(`File "${file.name}" exceeds 20MB limit. Please configure your IPFS pinning service in Settings to upload large files.`);
+                }
+                try {
+                    const cid = yield this.uploadToUserIPFS(file, ipfsConfig, options === null || options === void 0 ? void 0 : options.progressCallback);
+                    const { fileKey } = yield this.registerIpfsFile(cid, file.name, file.type);
+                    info = { key: fileKey, uploadId: "" };
+                }
+                catch (error) {
+                    throw new APIError(`Failed to upload file "${file.name}" to IPFS: ${getErrorMessage(error)}`);
                 }
             }
-            catch (error) {
-                if (error instanceof APIError || error instanceof WalletError)
-                    throw error;
-                throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+            else {
+                // Normal file - use S3
+                try {
+                    info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, options);
+                    if (!info || !info.key) {
+                        throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof APIError || error instanceof WalletError)
+                        throw error;
+                    throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                }
             }
             if (file.type) {
                 metadata.mimetype = file.type;
@@ -8607,7 +8942,7 @@ class Origin {
             if (previewImageIpfsHash) {
                 metadata.image = `ipfs://${previewImageIpfsHash}`;
             }
-            const deadline = BigInt(Date.now() + 600000); // 10 minutes from now
+            const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); // 10 minutes from now
             if (this.baseParentId) {
                 if (!parents) {
                     parents = [];
@@ -8621,7 +8956,10 @@ class Origin {
                 parents, this.appId);
             }
             catch (error) {
-                yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                // Only update S3 status if we have an uploadId (non-IPFS flow)
+                if (info.uploadId) {
+                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                }
                 throw new Error(`Failed to register IpNFT: ${error instanceof Error ? error.message : String(error)}`);
             }
             const { tokenId, signerAddress, creatorContentHash, signature, uri } = registration;
@@ -8635,12 +8973,18 @@ class Origin {
             try {
                 const mintResult = yield this.mintWithSignature(account, tokenId, parents || [], true, creatorContentHash, uri, license, deadline, signature, this.appId);
                 if (["0x1", "success"].indexOf(mintResult.receipt.status) === -1) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    // Only update S3 status if we have an uploadId (non-IPFS flow)
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Minting failed with status: ${mintResult.receipt.status}`);
                 }
             }
             catch (error) {
-                yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                // Only update S3 status if we have an uploadId (non-IPFS flow)
+                if (info.uploadId) {
+                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                }
                 throw new Error(`Minting transaction failed: ${error instanceof Error ? error.message : String(error)}`);
             }
             return tokenId.toString();
@@ -8687,10 +9031,15 @@ class Origin {
                 const { file, metadata, license } = entry;
                 let { parents } = entry;
                 // Upload file
+                const shouldUseIpfs = (options === null || options === void 0 ? void 0 : options.forceIpfs) || file.size > constants.MAX_FILE_SIZE;
                 let info;
-                try {
-                    info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, {
-                        progressCallback: (percent) => {
+                if (shouldUseIpfs) {
+                    const ipfsConfig = yield this.getIpfsUploadConfig();
+                    if (!ipfsConfig) {
+                        throw new APIError(`File "${file.name}" exceeds 20MB limit. Please configure your IPFS pinning service in Settings to upload large files.`);
+                    }
+                    try {
+                        const cid = yield this.uploadToUserIPFS(file, ipfsConfig, (percent) => {
                             var _a;
                             (_a = options === null || options === void 0 ? void 0 : options.progressCallback) === null || _a === void 0 ? void 0 : _a.call(options, {
                                 fileIndex: i,
@@ -8698,16 +9047,38 @@ class Origin {
                                 stage: "uploading",
                                 percent,
                             });
-                        },
-                    });
-                    if (!info || !info.key) {
-                        throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                        });
+                        const { fileKey } = yield this.registerIpfsFile(cid, file.name, file.type);
+                        info = { key: fileKey, uploadId: "" };
+                    }
+                    catch (error) {
+                        if (error instanceof APIError)
+                            throw error;
+                        throw new APIError(`Failed to upload file "${file.name}" to IPFS: ${getErrorMessage(error)}`);
                     }
                 }
-                catch (error) {
-                    if (error instanceof APIError || error instanceof WalletError)
-                        throw error;
-                    throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                else {
+                    try {
+                        info = yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_uploadFile).call(this, file, {
+                            progressCallback: (percent) => {
+                                var _a;
+                                (_a = options === null || options === void 0 ? void 0 : options.progressCallback) === null || _a === void 0 ? void 0 : _a.call(options, {
+                                    fileIndex: i,
+                                    fileCount: entries.length,
+                                    stage: "uploading",
+                                    percent,
+                                });
+                            },
+                        });
+                        if (!info || !info.key) {
+                            throw new APIError(`Failed to upload file "${file.name}": no upload info returned from server`);
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof APIError || error instanceof WalletError)
+                            throw error;
+                        throw new APIError(`Failed to upload file "${file.name}": ${getErrorMessage(error)}`);
+                    }
                 }
                 uploadInfos.push(info);
                 // Set mimetype
@@ -8725,7 +9096,7 @@ class Origin {
                 if (previewImageIpfsHash) {
                     metadata.image = `ipfs://${previewImageIpfsHash}`;
                 }
-                const deadline = BigInt(Date.now() + 600000); // 10 minutes from now
+                const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); // 10 minutes from now
                 // Prepare parents
                 if (this.baseParentId) {
                     if (!parents) {
@@ -8747,12 +9118,16 @@ class Origin {
                     parents, this.appId);
                 }
                 catch (error) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Failed to register IpNFT for file "${file.name}": ${error instanceof Error ? error.message : String(error)}`);
                 }
                 const { tokenId, creatorContentHash, signature, uri } = registration;
                 if (!tokenId || !creatorContentHash || signature === undefined || !uri) {
-                    yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    if (info.uploadId) {
+                        yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
+                    }
                     throw new Error(`Failed to register IpNFT for file "${file.name}": Missing required fields in registration response.`);
                 }
                 tokenIds.push(tokenId.toString());
@@ -8781,8 +9156,10 @@ class Origin {
                 return { tokenIds, result };
             }
             catch (error) {
-                // Mark all uploads as failed
+                // Mark all S3 uploads as failed (skip IPFS entries with no uploadId)
                 for (const info of uploadInfos) {
+                    if (!info.uploadId)
+                        continue;
                     try {
                         yield __classPrivateFieldGet(this, _Origin_instances, "m", _Origin_setOriginStatus).call(this, info.key, info.uploadId, []);
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@campnetwork/origin",
-  "version": "1.4.0-alpha.4",
+  "version": "1.4.0-alpha.6",
   "main": "dist/core.cjs",
   "exports": {
     ".": {