@startinblox/core 2.0.5-beta.5 → 2.0.6-beta.1

package/dist/{store-BJtCXbgT.js → store-_JtvdYph.js}

@@ -171,6 +171,9 @@ let __tla = (async () => {
       __publicField(this, "authToken", null);
       __publicField(this, "contractNegotiations", /* @__PURE__ */ new Map());
       __publicField(this, "transferProcesses", /* @__PURE__ */ new Map());
+      __publicField(this, "contractAgreements", /* @__PURE__ */ new Map());
+      __publicField(this, "assetAgreements", /* @__PURE__ */ new Map());
+      __publicField(this, "edrTokens", /* @__PURE__ */ new Map());
       var _a2, _b;
       this.validateConfig(config);
       this.config = config;
@@ -192,6 +195,15 @@ let __tla = (async () => {
       if (missing.length > 0) {
         throw new Error(`Missing required configuration: ${missing.join(", ")}`);
       }
+      if (!config.edrsEndpoint) {
+        config.edrsEndpoint = config.catalogEndpoint.replace("/catalog/request", "/edrs");
+      }
+      if (!config.publicEndpoint) {
+        if (config.endpoint) {
+          const baseUrl = config.endpoint.replace("/management", "");
+          config.publicEndpoint = `${baseUrl}/public`;
+        }
+      }
     }
     async getData(args) {
       if ("targetType" in args) {
@@ -216,7 +228,6 @@ let __tla = (async () => {
     async getCatalog(counterPartyAddress) {
       await this.ensureAuthenticated();
       const catalogRequest = this.buildV3CatalogRequest(counterPartyAddress);
-      console.log("Sending v3 catalog request:", JSON.stringify(catalogRequest, null, 2));
       const response = await this.fetchAuthn(this.config.catalogEndpoint, {
         method: "POST",
         headers: this.headers,
@@ -280,6 +291,110 @@ let __tla = (async () => {
     getNegotiationStatus(negotiationId) {
       return this._getNegotiationStatus(negotiationId);
     }
+    async getContractAgreement(negotiationId) {
+      await this.ensureAuthenticated();
+      try {
+        const response = await this.fetchAuthn(`${this.config.contractNegotiationEndpoint}/${negotiationId}/agreement`, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (!response.ok) {
+          console.error(`Failed to get contract agreement: ${response.status} ${response.statusText}`);
+          return null;
+        }
+        const agreement = await response.json();
+        this.contractAgreements.set(agreement["@id"], agreement);
+        const assetId = agreement.assetId;
+        if (assetId) {
+          const existing = this.assetAgreements.get(assetId);
+          const mapping = {
+            assetId,
+            catalogId: existing == null ? void 0 : existing.catalogId,
+            agreementId: agreement["@id"],
+            agreement,
+            negotiationId,
+            transferId: existing == null ? void 0 : existing.transferId,
+            edrToken: existing == null ? void 0 : existing.edrToken,
+            createdAt: (existing == null ? void 0 : existing.createdAt) || Date.now(),
+            lastUpdated: Date.now()
+          };
+          this.assetAgreements.set(assetId, mapping);
+        }
+        return agreement;
+      } catch (error2) {
+        console.error("Error retrieving contract agreement:", error2);
+        return null;
+      }
+    }
+    getStoredContractAgreement(assetId) {
+      const mapping = this.assetAgreements.get(assetId);
+      return (mapping == null ? void 0 : mapping.agreement) || null;
+    }
+    async getAllContractNegotiations() {
+      await this.ensureAuthenticated();
+      try {
+        const requestEndpoint = `${this.config.contractNegotiationEndpoint}/request`;
+        const response = await this.fetchAuthn(requestEndpoint, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify({
+            "@context": {
+              "@vocab": "https://w3id.org/edc/v0.0.1/ns/"
+            },
+            "@type": "QuerySpec",
+            offset: 0,
+            limit: 1e3
+          })
+        });
+        if (!response.ok) {
+          const getResponse = await this.fetchAuthn(`${this.config.contractNegotiationEndpoint}?offset=0&limit=1000`, {
+            method: "GET",
+            headers: this.headers
+          });
+          if (!getResponse.ok) {
+            console.warn(`Failed to fetch contract negotiations: ${getResponse.status} ${getResponse.statusText}`);
+            return [];
+          }
+          const getData = await getResponse.json();
+          return Array.isArray(getData) ? getData : getData.items || [];
+        }
+        const data = await response.json();
+        return Array.isArray(data) ? data : data.items || [];
+      } catch (error2) {
+        console.error("Error fetching contract negotiations:", error2);
+        return [];
+      }
+    }
+    async loadExistingAgreements() {
+      try {
+        const negotiations = await this.getAllContractNegotiations();
+        let _loadedCount = 0;
+        for (const negotiation of negotiations) {
+          if (negotiation.state === "FINALIZED" || negotiation.state === "AGREED") {
+            try {
+              const agreement = await this.getContractAgreement(negotiation["@id"]);
+              if (agreement) {
+                _loadedCount++;
+              }
+            } catch (error2) {
+              console.warn(`\u26A0\uFE0F Failed to load agreement for negotiation ${negotiation["@id"]}:`, error2);
+            }
+          }
+        }
+      } catch (error2) {
+        console.error("Error loading existing agreements:", error2);
+      }
+    }
+    getAllAssetAgreements() {
+      return Array.from(this.assetAgreements.values());
+    }
+    getAssetAgreement(assetId) {
+      return this.assetAgreements.get(assetId) || null;
+    }
+    hasValidAgreement(assetId) {
+      const agreement = this.getAssetAgreement(assetId);
+      return agreement !== null;
+    }
     async initiateTransfer(counterPartyAddress, contractId, dataDestination) {
       await this.ensureAuthenticated();
       const transferRequest = {
@@ -305,21 +420,173 @@ let __tla = (async () => {
       this.transferProcesses.set(transferId, transfer);
       return transferId;
     }
+    async initiateEDRTransfer(assetId, counterPartyAddress, contractId) {
+      await this.ensureAuthenticated();
+      const edrRequest = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "https://w3id.org/edc/v0.0.1/ns/TransferRequest",
+        assetId,
+        protocol: "dataspace-protocol-http",
+        counterPartyAddress,
+        contractId,
+        transferType: "HttpData-PULL",
+        dataDestination: {
+          type: "HttpProxy"
+        }
+      };
+      const response = await this.fetchAuthn(this.config.transferProcessEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(edrRequest)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`EDR transfer initiation failed: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const edrResponse = await response.json();
+      const transferId = edrResponse["@id"];
+      const mapping = this.assetAgreements.get(assetId);
+      if (mapping) {
+        mapping.transferId = transferId;
+        mapping.lastUpdated = Date.now();
+        this.assetAgreements.set(assetId, mapping);
+      }
+      return transferId;
+    }
+    async getEDRToken(transferId, maxRetries = 10, retryDelay = 2e3) {
+      await this.ensureAuthenticated();
+      const edrsEndpoint = this.config.edrsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", "/edrs");
+      const requestUrl = `${edrsEndpoint}/${transferId}/dataaddress`;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          const response = await this.fetchAuthn(requestUrl, {
+            method: "GET",
+            headers: this.headers
+          });
+          if (response.ok) {
+            const edrDataAddress = await response.json();
+            this.edrTokens.set(transferId, edrDataAddress);
+            const assetMapping = Array.from(this.assetAgreements.values()).find((mapping) => mapping.transferId === transferId);
+            if (assetMapping) {
+              assetMapping.edrToken = edrDataAddress.authorization;
+              assetMapping.lastUpdated = Date.now();
+            }
+            return edrDataAddress;
+          }
+          const errorText = await response.text();
+          let errorObj;
+          try {
+            errorObj = JSON.parse(errorText);
+          } catch (_e) {
+            errorObj = {
+              message: errorText
+            };
+          }
+          console.warn(`\u26A0\uFE0F EDR token attempt ${attempt}/${maxRetries} failed: ${response.status} ${response.statusText}`, errorObj);
+          if (response.status === 404 && attempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            continue;
+          }
+          console.error(`\u274C Final EDR token retrieval failed: ${response.status} ${response.statusText}`, errorObj);
+          console.error(`\u{1F517} Request URL: ${requestUrl}`);
+          console.error(`\u{1F194} Transfer ID used: ${transferId}`);
+          throw new Error(`EDR token retrieval failed: ${response.status} ${response.statusText} - ${errorObj.message || errorText}`);
+        } catch (error2) {
+          if (attempt === maxRetries) {
+            throw error2;
+          }
+          console.warn(`\u26A0\uFE0F EDR token attempt ${attempt}/${maxRetries} error:`, error2);
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+      }
+      throw new Error(`Failed to retrieve EDR token after ${maxRetries} attempts`);
+    }
+    getStoredEDRToken(transferId) {
+      return this.edrTokens.get(transferId) || null;
+    }
+    async fetchWithEDRToken(edrDataAddress, additionalPath) {
+      const { endpoint, authorization } = edrDataAddress;
+      const url2 = additionalPath ? `${endpoint}${additionalPath}` : endpoint;
+      try {
+        const response = await fetch(url2, {
+          method: "GET",
+          headers: {
+            Authorization: authorization,
+            Accept: "application/json"
+          },
+          mode: "cors"
+        });
+        if (!response.ok) {
+          throw new Error(`EDR data fetch failed: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+      } catch (error2) {
+        console.error("Error fetching data with EDR token:", error2);
+        throw error2;
+      }
+    }
+    async accessAssetData(assetId, counterPartyAddress, policy, counterPartyId, additionalPath) {
+      try {
+        const existingMapping = this.assetAgreements.get(assetId);
+        if ((existingMapping == null ? void 0 : existingMapping.edrToken) && existingMapping.transferId) {
+          const edrDataAddress = this.edrTokens.get(existingMapping.transferId);
+          if (edrDataAddress) {
+            return await this.fetchWithEDRToken(edrDataAddress, additionalPath);
+          }
+        }
+        const negotiationId = await this.negotiateContract(counterPartyAddress, assetId, policy, counterPartyId);
+        return {
+          negotiationId,
+          status: "negotiation_initiated"
+        };
+      } catch (error2) {
+        console.error("Error in complete asset access flow:", error2);
+        throw error2;
+      }
+    }
+    async continueAssetAccess(negotiationId, assetId, counterPartyAddress, additionalPath) {
+      try {
+        const agreement = await this.getContractAgreement(negotiationId);
+        if (!agreement) {
+          throw new Error("Failed to retrieve contract agreement");
+        }
+        const transferId = await this.initiateEDRTransfer(assetId, counterPartyAddress, agreement["@id"]);
+        const edrDataAddress = await this.getEDRToken(transferId);
+        if (!edrDataAddress) {
+          throw new Error("Failed to retrieve EDR token");
+        }
+        const data = await this.fetchWithEDRToken(edrDataAddress, additionalPath);
+        return data;
+      } catch (error2) {
+        console.error("Error continuing asset access flow:", error2);
+        throw error2;
+      }
+    }
+    async accessStoredAssetData(assetId, additionalPath) {
+      const mapping = this.assetAgreements.get(assetId);
+      if (!(mapping == null ? void 0 : mapping.transferId)) {
+        throw new Error(`No stored transfer information for asset: ${assetId}`);
+      }
+      const edrDataAddress = this.edrTokens.get(mapping.transferId);
+      if (!edrDataAddress) {
+        throw new Error(`No stored EDR token for asset: ${assetId}`);
+      }
+      return await this.fetchWithEDRToken(edrDataAddress, additionalPath);
+    }
     async fetchThroughDataspace(resourceId) {
       try {
-        console.log(`Fetching resource through dataspace: ${resourceId}`);
         const catalog = await this.getCatalog();
         if (!catalog) {
           console.error("No catalog available");
           return null;
         }
-        console.log("Catalog received:", catalog);
         const dataset2 = this.findDatasetInCatalog(catalog, resourceId);
         if (!dataset2) {
           console.error(`Dataset ${resourceId} not found in catalog`);
           return null;
         }
-        console.log("Dataset found:", dataset2);
         return catalog;
       } catch (error2) {
         console.error("Dataspace fetch failed:", error2);
@@ -568,6 +835,331 @@ let __tla = (async () => {
         sortOrder: "ASC"
       };
     }
+    async getAllAssets(querySpec) {
+      return this.getAssets(querySpec);
+    }
+    async getAsset(assetId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const assetsEndpoint = this.config.assetsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/assets" : "/assets");
+      const response = await this.fetchAuthn(`${assetsEndpoint}/${assetId}`, {
+        method: "GET",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`Failed to get asset: ${response.status} ${response.statusText}`);
+      }
+      const asset = await response.json();
+      if (asset["@id"]) {
+        await this.cache.set(asset["@id"], asset);
+      }
+      return asset;
+    }
+    async createAsset(assetInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const assetsEndpoint = this.config.assetsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/assets" : "/assets");
+      const assetData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "Asset",
+        "@id": assetInput["@id"],
+        properties: assetInput.properties || {},
+        dataAddress: assetInput.dataAddress
+      };
+      const response = await this.fetchAuthn(assetsEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(assetData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create asset: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      let createdAsset;
+      try {
+        createdAsset = await response.json();
+      } catch {
+        createdAsset = {
+          "@type": "Asset",
+          "@id": assetInput["@id"],
+          properties: assetInput.properties,
+          dataAddress: assetInput.dataAddress,
+          createdAt: Date.now()
+        };
+      }
+      if (createdAsset["@id"]) {
+        await this.cache.set(createdAsset["@id"], createdAsset);
+      }
+      return createdAsset;
+    }
+    async updateAsset(assetId, assetInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const assetsEndpoint = this.config.assetsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/assets" : "/assets");
+      const assetData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "Asset",
+        "@id": assetInput["@id"],
+        properties: assetInput.properties || {},
+        dataAddress: assetInput.dataAddress
+      };
+      const response = await this.fetchAuthn(`${assetsEndpoint}/${assetId}`, {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify(assetData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to update asset: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const updatedAsset = {
+        "@type": "Asset",
+        "@id": assetInput["@id"],
+        properties: assetInput.properties,
+        dataAddress: assetInput.dataAddress,
+        createdAt: Date.now()
+      };
+      await this.cache.set(assetId, updatedAsset);
+      return updatedAsset;
+    }
+    async deleteAsset(assetId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const assetsEndpoint = this.config.assetsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/assets" : "/assets");
+      const response = await this.fetchAuthn(`${assetsEndpoint}/${assetId}`, {
+        method: "DELETE",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to delete asset: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      await this.cache.delete(assetId);
+      return true;
+    }
+    async getAllPolicies(querySpec) {
+      return this.getPolicyDefinitions(querySpec);
+    }
+    async getPolicy(policyId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const policiesEndpoint = this.config.policiesEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/policydefinitions" : "/policydefinitions");
+      const response = await this.fetchAuthn(`${policiesEndpoint}/${policyId}`, {
+        method: "GET",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`Failed to get policy: ${response.status} ${response.statusText}`);
+      }
+      const policy = await response.json();
+      if (policy["@id"]) {
+        await this.cache.set(policy["@id"], policy);
+      }
+      return policy;
+    }
+    async createPolicy(policyInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const policiesEndpoint = this.config.policiesEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/policydefinitions" : "/policydefinitions");
+      const policyData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/",
+          odrl: "http://www.w3.org/ns/odrl/2/"
+        },
+        "@type": "PolicyDefinition",
+        "@id": policyInput["@id"],
+        policy: policyInput.policy
+      };
+      const response = await this.fetchAuthn(policiesEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(policyData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create policy: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const createdPolicy = {
+        "@type": "PolicyDefinition",
+        "@id": policyInput["@id"],
+        policy: policyInput.policy,
+        createdAt: Date.now()
+      };
+      if (createdPolicy["@id"]) {
+        await this.cache.set(createdPolicy["@id"], createdPolicy);
+      }
+      return createdPolicy;
+    }
+    async updatePolicy(policyId, policyInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const policiesEndpoint = this.config.policiesEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/policydefinitions" : "/policydefinitions");
+      const policyData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/",
+          odrl: "http://www.w3.org/ns/odrl/2/"
+        },
+        "@type": "PolicyDefinition",
+        "@id": policyInput["@id"],
+        policy: policyInput.policy
+      };
+      const response = await this.fetchAuthn(`${policiesEndpoint}/${policyId}`, {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify(policyData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to update policy: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const updatedPolicy = {
+        "@type": "PolicyDefinition",
+        "@id": policyInput["@id"],
+        policy: policyInput.policy,
+        createdAt: Date.now()
+      };
+      await this.cache.set(policyId, updatedPolicy);
+      return updatedPolicy;
+    }
+    async deletePolicy(policyId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const policiesEndpoint = this.config.policiesEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/policydefinitions" : "/policydefinitions");
+      const response = await this.fetchAuthn(`${policiesEndpoint}/${policyId}`, {
+        method: "DELETE",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to delete policy: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      await this.cache.delete(policyId);
+      return true;
+    }
+    async getAllContractDefinitions(querySpec) {
+      return this.getContractDefinitions(querySpec);
+    }
+    async getContractDefinition(contractId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const contractDefsEndpoint = this.config.contractDefinitionsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/contractdefinitions" : "/contractdefinitions");
+      const response = await this.fetchAuthn(`${contractDefsEndpoint}/${contractId}`, {
+        method: "GET",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`Failed to get contract definition: ${response.status} ${response.statusText}`);
+      }
+      const contract = await response.json();
+      if (contract["@id"]) {
+        await this.cache.set(contract["@id"], contract);
+      }
+      return contract;
+    }
+    async createContractDefinition(contractInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const contractDefsEndpoint = this.config.contractDefinitionsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/contractdefinitions" : "/contractdefinitions");
+      const contractData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "ContractDefinition",
+        "@id": contractInput["@id"],
+        accessPolicyId: contractInput.accessPolicyId,
+        contractPolicyId: contractInput.contractPolicyId,
+        assetsSelector: contractInput.assetsSelector || []
+      };
+      const response = await this.fetchAuthn(contractDefsEndpoint, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(contractData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create contract definition: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const createdContract = {
+        "@type": "ContractDefinition",
+        "@id": contractInput["@id"],
+        accessPolicyId: contractInput.accessPolicyId,
+        contractPolicyId: contractInput.contractPolicyId,
+        assetsSelector: contractInput.assetsSelector,
+        createdAt: Date.now()
+      };
+      if (createdContract["@id"]) {
+        await this.cache.set(createdContract["@id"], createdContract);
+      }
+      return createdContract;
+    }
+    async updateContractDefinition(contractId, contractInput) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const contractDefsEndpoint = this.config.contractDefinitionsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/contractdefinitions" : "/contractdefinitions");
+      const contractData = {
+        "@context": {
+          "@vocab": "https://w3id.org/edc/v0.0.1/ns/",
+          edc: "https://w3id.org/edc/v0.0.1/ns/"
+        },
+        "@type": "ContractDefinition",
+        "@id": contractInput["@id"],
+        accessPolicyId: contractInput.accessPolicyId,
+        contractPolicyId: contractInput.contractPolicyId,
+        assetsSelector: contractInput.assetsSelector || []
+      };
+      const response = await this.fetchAuthn(`${contractDefsEndpoint}/${contractId}`, {
+        method: "PUT",
+        headers: this.headers,
+        body: JSON.stringify(contractData)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to update contract definition: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const updatedContract = {
+        "@type": "ContractDefinition",
+        "@id": contractInput["@id"],
+        accessPolicyId: contractInput.accessPolicyId,
+        contractPolicyId: contractInput.contractPolicyId,
+        assetsSelector: contractInput.assetsSelector,
+        createdAt: Date.now()
+      };
+      await this.cache.set(contractId, updatedContract);
+      return updatedContract;
+    }
+    async deleteContractDefinition(contractId) {
+      await this.ensureAuthenticated();
+      const apiVersion = this.config.apiVersion || "v3";
+      const contractDefsEndpoint = this.config.contractDefinitionsEndpoint || this.config.catalogEndpoint.replace("/catalog/request", apiVersion === "v3" ? "/contractdefinitions" : "/contractdefinitions");
+      const response = await this.fetchAuthn(`${contractDefsEndpoint}/${contractId}`, {
+        method: "DELETE",
+        headers: this.headers
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to delete contract definition: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      await this.cache.delete(contractId);
+      return true;
+    }
     async fetchAuthn(iri, options) {
       await this.ensureAuthenticated();
       return fetch(iri, {
@@ -662,9 +1254,7 @@ let __tla = (async () => {
       return token;
     }
     async getAllSelfDescriptions() {
-      console.log("Fetching all self-descriptions from Federated Catalogue...", this.fcBaseUrl);
       const token = await this.connect();
-      console.log("Token received:", token);
       const url2 = `${this.fcBaseUrl}/self-descriptions`;
       const headers = new Headers({
         Authorization: `Bearer ${token}`
@@ -672,7 +1262,6 @@ let __tla = (async () => {
       const response = await fetch(url2, {
         headers
       });
-      console.log("Response status:", response.status);
       return await response.json();
     }
     async getSelfDescriptionByHash(sdHash) {
@@ -839,7 +1428,6 @@ let __tla = (async () => {
       try {
         if (await this.cache.has(id)) {
           await this.cache.delete(id);
-          console.log(`[FederatedCatalogueStore] Cleared cache for ${id}`);
         }
       } catch (error2) {
         console.error(`[FederatedCatalogueStore] Error clearing cache for ${id}:`, error2);
@@ -848,7 +1436,6 @@ let __tla = (async () => {
     async cacheResource(key, resourceProxy) {
       try {
         await this.cache.set(key, resourceProxy);
-        console.log(`[FederatedCatalogueStore] Cached resource ${key}`);
       } catch (error2) {
         console.error(`[FederatedCatalogueStore] Error caching resource ${key}:`, error2);
       }
@@ -873,7 +1460,6 @@ let __tla = (async () => {
           "@id": id
         };
         await this.cache.set(id, resourceWithId);
-        console.log(`[FederatedCatalogueStore] Stored local data for ${id}`);
         this.notifyComponents(id, resourceWithId);
         return id;
       } catch (error2) {
@@ -27544,10 +28130,8 @@ let __tla = (async () => {
       let indexUri;
       if (options.dataSrcIndex) {
         indexUri = options.dataSrcIndex;
-        console.log("\u{1F4C2} [SolidIndexingSearchProvider.queryIndex] Using direct index URI:", indexUri);
       } else if (options.dataSrcProfile) {
         indexUri = await this.discoverIndexFromProfile(options.dataSrcProfile);
-        console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndex] Discovered index URI from profile:", indexUri);
       } else {
         console.warn("Either dataSrcIndex or dataSrcProfile must be specified");
         return [];
@@ -27556,10 +28140,7 @@ let __tla = (async () => {
         console.warn("\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndex] Invalid index URI, returning empty results");
         return [];
       }
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndex] Starting query with options:", JSON.stringify(options, null, 2));
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndex] Filter values:", JSON.stringify(options.filterValues, null, 2));
       const filterFields = Object.entries(options.filterValues);
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndex] Filter fields:", filterFields);
       const firstField = filterFields[0];
       const firstFieldValue = firstField[1];
       let path = firstField[0];
@@ -27574,21 +28155,7 @@ let __tla = (async () => {
         fieldName = path.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
       }
       const searchPattern = firstFieldValue.value;
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndex] Parsed parameters:");
-      console.log("  - Path:", path);
-      console.log("  - Field name:", fieldName);
-      console.log("  - Search pattern:", searchPattern);
-      console.log("  - RDF type:", options.dataRdfType);
-      console.log("  - Exact match mapping:", options.exactMatchMapping);
-      console.log("\u{1F527} [SolidIndexingSearchProvider.queryIndex] Generating SHACL shapes...");
       const { targetShape, subIndexShape, finalShape } = this.generateShapes(options.dataRdfType, fieldName, searchPattern, options.exactMatchMapping);
-      console.log("\u{1F4DD} [SolidIndexingSearchProvider.queryIndex] Generated shapes:");
-      console.log("=== TARGET SHAPE ===");
-      console.log(targetShape);
-      console.log("=== SUBINDEX SHAPE ===");
-      console.log(subIndexShape);
-      console.log("=== FINAL SHAPE ===");
-      console.log(finalShape);
       const parser = new N3.Parser({
         format: "text/turtle"
       });
@@ -27602,10 +28169,7 @@ let __tla = (async () => {
       const entryTransformer = new EntryStreamTransformerDefaultImpl(SEMANTIZER);
       const finalIndexStrategy = new IndexStrategyFinalShapeDefaultImpl(finalIndexShapeGraph, subIndexShapeGraph, shaclValidator, entryTransformer);
       const shaclStrategy = new IndexQueryingStrategyShaclUsingFinalIndex(targetShapeGraph, finalIndexStrategy, shaclValidator, entryTransformer);
-      console.log("\u{1F527} [SolidIndexingSearchProvider.queryIndex] Creating index with factory...");
       const index = await SEMANTIZER.load(indexUri, indexFactory);
-      console.log("\u2705 [SolidIndexingSearchProvider.queryIndex] Index created successfully");
-      console.log("\u{1F680} [SolidIndexingSearchProvider.queryIndex] Starting query stream...");
       const resultStream = index.mixins.index.query(shaclStrategy);
       return new Promise((resolve, reject) => {
         const resultIds = [];
@@ -27614,22 +28178,17 @@ let __tla = (async () => {
         let streamEnded = false;
         const checkComplete = () => {
           if (streamEnded && pendingFetches === 0) {
-            console.log(`\u{1F3C1} [SolidIndexingSearchProvider.queryIndex] All resources fetched. Found ${resultIds.length} result IDs:`, resultIds);
-            console.log(`\u{1F3AF} [SolidIndexingSearchProvider.queryIndex] Returning ${resources.length} resources for ldp:contains`);
             resolve(resources);
           }
         };
         resultStream.on("data", async (result) => {
-          console.log("\u{1F4E6} [SolidIndexingSearchProvider.queryIndex] Received result:", result.value);
           if (result.value) {
             resultIds.push(result.value);
-            console.log("\u2705 [SolidIndexingSearchProvider.queryIndex] Added result ID:", result.value);
             pendingFetches++;
             try {
               const resource = await this.dataFetcher(result.value);
               if (resource) {
                 resources.push(resource);
-                console.log(`\u2705 [SolidIndexingSearchProvider.queryIndex] Successfully fetched resource: ${result.value}`);
               } else {
                 console.warn(`\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndex] Could not fetch resource: ${result.value}`);
               }
@@ -27646,7 +28205,6 @@ let __tla = (async () => {
           reject(error2);
         });
         resultStream.on("end", () => {
-          console.log(`\u{1F3C1} [SolidIndexingSearchProvider.queryIndex] Stream ended. Found ${resultIds.length} result IDs:`, resultIds);
           streamEnded = true;
           checkComplete();
         });
@@ -27657,9 +28215,7 @@ let __tla = (async () => {
         console.warn("\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndexConjunction] Invalid index URL:", options.dataSrcIndex, options.dataSrcProfile);
         return [];
       }
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Starting conjunction query with options:", JSON.stringify(options, null, 2));
       const filterFields = Object.entries(options.filterValues);
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Filter fields:", filterFields);
       if (filterFields.length === 0) {
         return [];
       }
@@ -27672,29 +28228,22 @@ let __tla = (async () => {
           },
           exactMatchMapping: options.exactMatchMapping
         };
-        console.log(`\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Executing query for ${propertyName}:`, queryOptions);
         return this.query(queryOptions);
       });
       try {
         const allResults = await Promise.all(queryPromises);
-        console.log("\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] All individual queries completed");
         if (allResults.length === 1) {
           return allResults[0];
         }
         const baseResults = allResults[0];
-        console.log(`\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Base results count: ${baseResults.length}`);
         const intersectionResults = baseResults.filter((resource) => {
           const resourceId = resource["@id"];
-          console.log(`\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Checking resource: ${resourceId}`);
-          const existsInAllSets = allResults.every((resultSet, index) => {
+          const existsInAllSets = allResults.every((resultSet, _index) => {
             const found = resultSet.some((r) => r["@id"] === resourceId);
-            console.log(`  - Set ${index}: ${found ? "\u2705" : "\u274C"} (${resultSet.length} items)`);
             return found;
           });
-          console.log(`  - Final result: ${existsInAllSets ? "\u2705 IN INTERSECTION" : "\u274C NOT IN INTERSECTION"}`);
           return existsInAllSets;
         });
-        console.log(`\u{1F50D} [SolidIndexingSearchProvider.queryIndexConjunction] Conjunction results count: ${intersectionResults.length}`);
         return intersectionResults;
       } catch (error2) {
         console.error("\u274C [SolidIndexingSearchProvider.queryIndexConjunction] Error in conjunction query:", error2);
@@ -27702,11 +28251,6 @@ let __tla = (async () => {
       }
     }
     generateShapes(rdfType, propertyName, pattern, exactMatchMapping) {
-      console.log("\u{1F527} [SolidIndexingSearchProvider.generateShapes] Generating shapes with parameters:");
-      console.log("  - RDF Type:", rdfType);
-      console.log("  - Property Name:", propertyName);
-      console.log("  - Pattern:", pattern);
-      console.log("  - Exact Match Mapping:", exactMatchMapping);
       const isExactMatch = exactMatchMapping == null ? void 0 : exactMatchMapping[propertyName];
       let matchValue;
       if (isExactMatch) {
@@ -27716,15 +28260,8 @@ let __tla = (async () => {
         const words = cleanPattern.split(" ").filter((word) => word.length >= 3);
         const prefix = words.length > 0 ? words[0].substring(0, 3) : pattern.substring(0, 3);
         matchValue = `${prefix}.*`;
-        console.log("  - Cleaned pattern:", cleanPattern);
-        console.log("  - Extracted words:", words);
-        console.log("  - Generated prefix:", prefix);
       }
       const matchConstraint = "sh:pattern";
-      console.log("  - Is Exact Match:", isExactMatch);
-      console.log("  - Match Value:", matchValue);
-      console.log("  - Match Constraint:", matchConstraint);
-      console.log("  - Generated SHACL constraint: [ sh:path", `${matchConstraint}; sh:hasValue "${matchValue}" ]`);
       const targetShape = `
 @prefix sh: <http://www.w3.org/ns/shacl#> .
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@@ -27882,7 +28419,6 @@ sh:property [
     extractPublicTypeIndexUrl(profileData) {
       var _a2, _b;
       const profileDoc = (_a2 = profileData["@graph"]) == null ? void 0 : _a2.find((item) => item["@type"] === "foaf:PersonalProfileDocument");
-      console.log("\u{1F50D} [SolidIndexingSearchProvider.extractPublicTypeIndexUrl] Profile document:", profileDoc);
       if (profileDoc == null ? void 0 : profileDoc["foaf:primaryTopic"]) {
         const primaryTopicId = profileDoc == null ? void 0 : profileDoc["foaf:primaryTopic"];
         const primaryTopic = (_b = profileData["@graph"]) == null ? void 0 : _b.find((item) => item["@id"] === primaryTopicId);
@@ -27963,7 +28499,7 @@ sh:property [
       this.searchProvider = new SolidIndexingSearchProvider(this.getData.bind(this));
     }
     async initGetter() {
-      const { CustomGetter } = await import("./custom-getter-FYE7WERU.js");
+      const { CustomGetter } = await import("./custom-getter-cITbP3Tj.js");
       return CustomGetter;
     }
     async getData(id, context2, parentId, localData, forceFetch, serverPagination, serverSearch, headers, bypassLoadingList) {
@@ -32327,7 +32863,6 @@ sh:property [
     }
     async load(uri, _otherFetch) {
       const headers = store$1.headers;
-      console.log(`Loading\xB7specific\xB7URI\xB7${uri}`);
       const response = await store$1.fetchAuthn(uri, {
         method: "GET",
         headers,
@@ -32373,7 +32908,6 @@ sh:property [
           input.push(null);
         }
       });
-      console.log("[IndexLoader] Input loaded", input);
       const parserJsonld = new Parser();
       const quads = parserJsonld.import(input);
       const resDataset = factory.dataset();