@startinblox/core 2.0.6-beta.1 → 2.0.6-beta.10

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

@@ -1,15 +1,15 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { l as isUrlOrRelativePath, m as jsonldContextParserExports, o as getRawContext, n as normalizeContext, q as mergeContexts, c as doesResourceContainList, r as requireJsonldContextParser, v as requireErrorCoded, w as requireLink } from "./helpers-vZrb1UDN.js";
-let StoreService, formatAttributesToServerSearchOptions, base_context, StoreType, StoreFactory, hasQueryIndex, formatAttributesToServerPaginationOptions, getDefaultExportFromCjs, hasSetLocalData, sibStore, mergeServerSearchOptions, semantizer;
+import { l as isUrlOrRelativePath, m as jsonldContextParserExports, o as getRawContext, n as normalizeContext, q as mergeContexts, c as doesResourceContainList, r as requireJsonldContextParser, v as requireErrorCoded, w as requireLink } from "./helpers-DtCY-jxq.js";
+let AuthFetchResolver, DEFAULT_AUTH_SELECTORS, StoreService, formatAttributesToServerSearchOptions, base_context, StoreType, StoreFactory, hasQueryIndex, formatAttributesToServerPaginationOptions, getDefaultExportFromCjs, hasSetLocalData, sibStore, mergeServerSearchOptions, semantizer;
 let __tla = (async () => {
   var _a;
   getDefaultExportFromCjs = function(x) {
     return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
   };
   function getAugmentedNamespace(n) {
-    if (n.__esModule) return n;
+    if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
     var f = n.default;
     if (typeof f == "function") {
       var a = function a2() {
@@ -162,7 +162,21 @@ let __tla = (async () => {
       return false;
     }
   }
-  class DataspaceConnectorStore {
+  class AssetValidationError extends Error {
+    constructor(message, assetId, validationType, reason, details) {
+      super(message);
+      __publicField(this, "assetId");
+      __publicField(this, "validationType");
+      __publicField(this, "reason");
+      __publicField(this, "details");
+      this.name = "AssetValidationError";
+      this.assetId = assetId;
+      this.validationType = validationType;
+      this.reason = reason;
+      this.details = details;
+    }
+  }
+  const _DataspaceConnectorStore = class _DataspaceConnectorStore {
     constructor(config) {
       __publicField(this, "cache");
       __publicField(this, "session");
@@ -184,6 +198,12 @@ let __tla = (async () => {
         Accept: "application/json"
       };
     }
+    _makeAssetAgreementKey(assetId, providerParticipantId) {
+      if (providerParticipantId) {
+        return `${assetId}:${providerParticipantId}`;
+      }
+      return assetId;
+    }
     validateConfig(config) {
       const required = [
         "catalogEndpoint",
@@ -254,6 +274,21 @@ let __tla = (async () => {
     }
     async negotiateContract(counterPartyAddress, _offerId, policy, counterPartyId) {
       await this.ensureAuthenticated();
+      console.log("[DataspaceConnectorStore] Received policy for negotiation:", policy);
+      console.log("[DataspaceConnectorStore] Policy keys:", Object.keys(policy));
+      const cleanPolicy = {};
+      for (const key in policy) {
+        if (!/^\d+$/.test(key)) {
+          cleanPolicy[key] = policy[key];
+        } else {
+          console.warn(`[DataspaceConnectorStore] Removing numeric key "${key}" from policy`);
+        }
+      }
+      console.log("[DataspaceConnectorStore] Cleaned policy keys:", Object.keys(cleanPolicy));
+      const targetAssetId = _offerId || cleanPolicy.target || cleanPolicy["odrl:target"] || policy.target || policy["odrl:target"];
+      if (!targetAssetId) {
+        console.warn("[DataspaceConnectorStore] No target asset ID found for negotiation");
+      }
       const negotiationRequest = {
         "@context": {
           "@vocab": "https://w3id.org/edc/v0.0.1/ns/"
@@ -264,12 +299,15 @@ let __tla = (async () => {
         protocol: "dataspace-protocol-http",
         policy: {
           "@context": "http://www.w3.org/ns/odrl.jsonld",
-          "@id": policy["@id"],
-          "@type": "Offer",
-          assigner: counterPartyId || "provider",
-          target: policy.target
+          ...cleanPolicy,
+          "@type": "odrl:Offer",
+          assigner: cleanPolicy.assigner || policy.assigner || counterPartyId || "provider",
+          target: targetAssetId,
+          "odrl:target": targetAssetId
         }
       };
+      console.log("[DataspaceConnectorStore] Contract negotiation request:", JSON.stringify(negotiationRequest, null, 2));
+      console.log("[DataspaceConnectorStore] \u{1F50D} POSTing negotiation to consumer connector:", this.config.contractNegotiationEndpoint);
       const response = await this.fetchAuthn(this.config.contractNegotiationEndpoint, {
         method: "POST",
         headers: this.headers,
@@ -291,7 +329,7 @@ let __tla = (async () => {
     getNegotiationStatus(negotiationId) {
       return this._getNegotiationStatus(negotiationId);
     }
-    async getContractAgreement(negotiationId) {
+    async getContractAgreement(negotiationId, providerParticipantId) {
       await this.ensureAuthenticated();
       try {
         const response = await this.fetchAuthn(`${this.config.contractNegotiationEndpoint}/${negotiationId}/agreement`, {
@@ -306,9 +344,11 @@ let __tla = (async () => {
         this.contractAgreements.set(agreement["@id"], agreement);
         const assetId = agreement.assetId;
         if (assetId) {
-          const existing = this.assetAgreements.get(assetId);
+          const key = this._makeAssetAgreementKey(assetId, providerParticipantId);
+          const existing = this.assetAgreements.get(key);
           const mapping = {
             assetId,
+            providerParticipantId,
             catalogId: existing == null ? void 0 : existing.catalogId,
             agreementId: agreement["@id"],
             agreement,
@@ -318,7 +358,7 @@ let __tla = (async () => {
             createdAt: (existing == null ? void 0 : existing.createdAt) || Date.now(),
             lastUpdated: Date.now()
           };
-          this.assetAgreements.set(assetId, mapping);
+          this.assetAgreements.set(key, mapping);
         }
         return agreement;
       } catch (error2) {
@@ -326,8 +366,9 @@ let __tla = (async () => {
         return null;
       }
     }
-    getStoredContractAgreement(assetId) {
-      const mapping = this.assetAgreements.get(assetId);
+    getStoredContractAgreement(assetId, providerParticipantId) {
+      const key = this._makeAssetAgreementKey(assetId, providerParticipantId);
+      const mapping = this.assetAgreements.get(key);
       return (mapping == null ? void 0 : mapping.agreement) || null;
     }
     async getAllContractNegotiations() {
@@ -388,11 +429,12 @@ let __tla = (async () => {
     getAllAssetAgreements() {
       return Array.from(this.assetAgreements.values());
     }
-    getAssetAgreement(assetId) {
-      return this.assetAgreements.get(assetId) || null;
+    getAssetAgreement(assetId, providerParticipantId) {
+      const key = this._makeAssetAgreementKey(assetId, providerParticipantId);
+      return this.assetAgreements.get(key) || null;
     }
-    hasValidAgreement(assetId) {
-      const agreement = this.getAssetAgreement(assetId);
+    hasValidAgreement(assetId, providerParticipantId) {
+      const agreement = this.getAssetAgreement(assetId, providerParticipantId);
       return agreement !== null;
     }
     async initiateTransfer(counterPartyAddress, contractId, dataDestination) {
@@ -420,7 +462,7 @@ let __tla = (async () => {
       this.transferProcesses.set(transferId, transfer);
       return transferId;
     }
-    async initiateEDRTransfer(assetId, counterPartyAddress, contractId) {
+    async initiateEDRTransfer(assetId, counterPartyAddress, contractId, providerParticipantId) {
       await this.ensureAuthenticated();
       const edrRequest = {
         "@context": {
@@ -447,11 +489,12 @@ let __tla = (async () => {
       }
       const edrResponse = await response.json();
       const transferId = edrResponse["@id"];
-      const mapping = this.assetAgreements.get(assetId);
+      const key = this._makeAssetAgreementKey(assetId, providerParticipantId);
+      const mapping = this.assetAgreements.get(key);
       if (mapping) {
         mapping.transferId = transferId;
         mapping.lastUpdated = Date.now();
-        this.assetAgreements.set(assetId, mapping);
+        this.assetAgreements.set(key, mapping);
       }
       return transferId;
     }
@@ -529,7 +572,8 @@ let __tla = (async () => {
     }
     async accessAssetData(assetId, counterPartyAddress, policy, counterPartyId, additionalPath) {
       try {
-        const existingMapping = this.assetAgreements.get(assetId);
+        const key = this._makeAssetAgreementKey(assetId, counterPartyId);
+        const existingMapping = this.assetAgreements.get(key);
         if ((existingMapping == null ? void 0 : existingMapping.edrToken) && existingMapping.transferId) {
           const edrDataAddress = this.edrTokens.get(existingMapping.transferId);
           if (edrDataAddress) {
@@ -546,13 +590,13 @@ let __tla = (async () => {
         throw error2;
       }
     }
-    async continueAssetAccess(negotiationId, assetId, counterPartyAddress, additionalPath) {
+    async continueAssetAccess(negotiationId, assetId, counterPartyAddress, additionalPath, providerParticipantId) {
       try {
-        const agreement = await this.getContractAgreement(negotiationId);
+        const agreement = await this.getContractAgreement(negotiationId, providerParticipantId);
         if (!agreement) {
           throw new Error("Failed to retrieve contract agreement");
         }
-        const transferId = await this.initiateEDRTransfer(assetId, counterPartyAddress, agreement["@id"]);
+        const transferId = await this.initiateEDRTransfer(assetId, counterPartyAddress, agreement["@id"], providerParticipantId);
         const edrDataAddress = await this.getEDRToken(transferId);
         if (!edrDataAddress) {
           throw new Error("Failed to retrieve EDR token");
@@ -564,8 +608,9 @@ let __tla = (async () => {
         throw error2;
       }
     }
-    async accessStoredAssetData(assetId, additionalPath) {
-      const mapping = this.assetAgreements.get(assetId);
+    async accessStoredAssetData(assetId, additionalPath, providerParticipantId) {
+      const key = this._makeAssetAgreementKey(assetId, providerParticipantId);
+      const mapping = this.assetAgreements.get(key);
       if (!(mapping == null ? void 0 : mapping.transferId)) {
         throw new Error(`No stored transfer information for asset: ${assetId}`);
       }
@@ -575,6 +620,107 @@ let __tla = (async () => {
       }
       return await this.fetchWithEDRToken(edrDataAddress, additionalPath);
     }
+    async fetchProtectedResource(resourceUrl, consumerParticipantId, consumerConnectorUrl, providerConnectorUrl, existingAgreementId, maxNegotiationRetries = 30, negotiationRetryDelay = 2e3) {
+      console.log(`\u{1F510} Requesting protected resource: ${resourceUrl}`);
+      if (existingAgreementId) {
+        console.log(`\u{1F4DC} Using existing agreement: ${existingAgreementId}`);
+        return await this._fetchWithAgreement(resourceUrl, consumerParticipantId, consumerConnectorUrl, existingAgreementId);
+      }
+      const initialResponse = await fetch(resourceUrl, {
+        method: "GET",
+        headers: {
+          "DSP-PARTICIPANT-ID": consumerParticipantId,
+          "DSP-CONSUMER-CONNECTORURL": consumerConnectorUrl,
+          Accept: "application/ld+json"
+        },
+        mode: "cors"
+      });
+      if (initialResponse.ok) {
+        const data2 = await initialResponse.json();
+        console.log("\u2705 Resource accessed successfully (no agreement required)");
+        return data2;
+      }
+      if (initialResponse.status !== 449) {
+        const errorText = await initialResponse.text();
+        throw new Error(`Unexpected response: ${initialResponse.status} ${initialResponse.statusText} - ${errorText}`);
+      }
+      const contractInfo = await this._handlePolicyDiscovery(initialResponse, providerConnectorUrl, maxNegotiationRetries, negotiationRetryDelay);
+      console.log("\u{1F504} Retrying resource request with agreement...");
+      const data = await this._fetchWithAgreement(resourceUrl, consumerParticipantId, consumerConnectorUrl, contractInfo.agreementId);
+      if (data && typeof data === "object") {
+        data[_DataspaceConnectorStore.AUTO_NEGOTIATED_CONTRACT_KEY] = {
+          agreementId: contractInfo.agreementId,
+          negotiationId: contractInfo.negotiationId,
+          assetId: contractInfo.assetId,
+          providerId: contractInfo.providerId,
+          providerConnectorUrl,
+          policy: contractInfo.policy,
+          resourceUrl
+        };
+      }
+      return data;
+    }
+    async _handlePolicyDiscovery(initialResponse, providerConnectorUrl, maxNegotiationRetries, negotiationRetryDelay) {
+      console.log("\u{1F4CB} Contract negotiation required (449 response)");
+      const errorResponse = await initialResponse.json();
+      const suggestedPolicies = errorResponse.suggested_policies;
+      if (!suggestedPolicies || suggestedPolicies.length === 0) {
+        throw new Error("No suggested policies returned in 449 response");
+      }
+      const bestPolicy = suggestedPolicies.reduce((best, current) => {
+        return current.openness_score > best.openness_score ? current : best;
+      });
+      console.log(`\u{1F4DC} Selected policy: ${bestPolicy.policy_id} (openness: ${bestPolicy.openness_score})`);
+      const providerId = errorResponse.provider_id || errorResponse.participant_id;
+      const assetId = errorResponse.asset_id;
+      console.log(`\u{1F3E2} Provider ID for negotiation: ${providerId}`);
+      console.log("\u{1F91D} Initiating contract negotiation...");
+      const negotiationId = await this.negotiateContract(providerConnectorUrl, assetId, bestPolicy.policy, providerId);
+      console.log(`\u{1F4DD} Negotiation initiated: ${negotiationId}`);
+      for (let attempt = 1; attempt <= maxNegotiationRetries; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, negotiationRetryDelay));
+        const status = await this._getNegotiationStatus(negotiationId);
+        console.log(`\u23F3 Negotiation status (${attempt}/${maxNegotiationRetries}): ${status.state}`);
+        if (status.state === "FINALIZED") {
+          const agreement = await this.getContractAgreement(negotiationId, providerId);
+          if (!agreement) {
+            throw new Error(`Failed to retrieve contract agreement for negotiation ${negotiationId}`);
+          }
+          console.log(`\u2705 Agreement obtained: ${agreement["@id"]}`);
+          return {
+            agreementId: agreement["@id"],
+            negotiationId,
+            assetId,
+            providerId,
+            policy: bestPolicy.policy
+          };
+        }
+        if (status.state === "TERMINATED") {
+          throw new Error(`Negotiation terminated: ${status.errorDetail || "Unknown reason"}`);
+        }
+      }
+      throw new Error(`Negotiation ${negotiationId} failed or timed out after ${maxNegotiationRetries} attempts`);
+    }
+    async _fetchWithAgreement(resourceUrl, consumerParticipantId, providerConnectorUrl, agreementId) {
+      console.log(`\u{1F510} Requesting protected resource: ${resourceUrl} (with agreement)`);
+      const response = await fetch(resourceUrl, {
+        method: "GET",
+        headers: {
+          "DSP-PARTICIPANT-ID": consumerParticipantId,
+          "DSP-CONSUMER-CONNECTORURL": providerConnectorUrl,
+          "DSP-AGREEMENT-ID": agreementId,
+          Accept: "application/ld+json"
+        },
+        mode: "cors"
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to access protected resource: ${response.status} ${response.statusText} - ${errorText}`);
+      }
+      const data = await response.json();
+      console.log("\u2705 Resource accessed successfully");
+      return data;
+    }
     async fetchThroughDataspace(resourceId) {
       try {
         const catalog = await this.getCatalog();
@@ -610,11 +756,11 @@ let __tla = (async () => {
     async ensureAuthenticated() {
       if (this.authToken && this.headers) return;
       switch (this.config.authMethod) {
-        case "edc-api-key":
-          if (!this.config.edcApiKey) {
-            throw new Error("EDC API key required but not provided. Set edcApiKey in configuration.");
+        case "dsp-api-key":
+          if (!this.config.dspApiKey) {
+            throw new Error("DSP API key required but not provided. Set dspApiKey in configuration.");
           }
-          this.authToken = this.config.edcApiKey;
+          this.authToken = this.config.dspApiKey;
           this.headers = {
             ...this.headers,
             "X-Api-Key": this.authToken
@@ -900,39 +1046,60 @@ let __tla = (async () => {
     }
     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 hasAgreement = this.hasValidAgreement(assetId);
+      if (hasAgreement) {
+        const message = `Cannot update asset ${assetId}: Asset has active contract agreements. Deleting an asset with agreements would invalidate existing contracts. Please terminate or complete all negotiations first.`;
+        throw new AssetValidationError(message, assetId, "update", "agreements");
+      }
+      const negotiations = await this.getAllContractNegotiations();
+      const activeNegotiations = negotiations.filter((neg) => neg.state !== "FINALIZED" && neg.state !== "TERMINATED" && neg.assetId === assetId);
+      if (activeNegotiations.length > 0) {
+        const message = `Cannot update asset ${assetId}: Asset has ${activeNegotiations.length} active contract negotiation(s). Please wait for negotiations to complete or terminate them first.`;
+        throw new AssetValidationError(message, assetId, "update", "negotiations", {
+          negotiationCount: activeNegotiations.length,
+          negotiations: activeNegotiations
+        });
+      }
+      console.log(`\u26A0\uFE0F  Using DELETE + POST pattern to update asset ${assetId}`);
+      try {
+        const deleted = await this.deleteAsset(assetId, true);
+        if (!deleted) {
+          throw new Error(`Failed to delete existing asset ${assetId} for update`);
+        }
+      } catch (deleteError) {
+        if (deleteError instanceof AssetValidationError) {
+          throw new AssetValidationError(deleteError.message.replace("Cannot delete", "Cannot update"), assetId, "update", deleteError.reason, deleteError.details);
+        }
+        throw deleteError;
+      }
+      try {
+        const updatedAsset = await this.createAsset(assetInput);
+        console.log(`\u2705 Asset ${assetId} updated successfully via DELETE + POST`);
+        return updatedAsset;
+      } catch (createError) {
+        console.error(`\u274C Critical: Failed to recreate asset ${assetId} after deletion`, createError);
+        const errorMessage = createError instanceof Error ? createError.message : String(createError);
+        throw new Error(`Failed to recreate asset after deletion: ${errorMessage}. Asset ${assetId} has been deleted but not recreated.`);
       }
-      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) {
+    async deleteAsset(assetId, skipAgreementCheck = false) {
       await this.ensureAuthenticated();
+      if (!skipAgreementCheck) {
+        const hasAgreement = this.hasValidAgreement(assetId);
+        if (hasAgreement) {
+          const message = `Cannot delete asset ${assetId}: Asset has active contract agreements. Deleting an asset with agreements would invalidate existing contracts. Please terminate or complete all negotiations first.`;
+          throw new AssetValidationError(message, assetId, "delete", "agreements");
+        }
+        const negotiations = await this.getAllContractNegotiations();
+        const activeNegotiations = negotiations.filter((neg) => neg.state !== "FINALIZED" && neg.state !== "TERMINATED" && neg.assetId === assetId);
+        if (activeNegotiations.length > 0) {
+          const message = `Cannot delete asset ${assetId}: Asset has ${activeNegotiations.length} active contract negotiation(s). Please wait for negotiations to complete or terminate them first.`;
+          throw new AssetValidationError(message, assetId, "delete", "negotiations", {
+            negotiationCount: activeNegotiations.length,
+            negotiations: activeNegotiations
+          });
+        }
+      }
       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}`, {
@@ -941,9 +1108,28 @@ let __tla = (async () => {
       });
       if (!response.ok) {
         const errorText = await response.text();
+        if (response.status === 409) {
+          try {
+            const errorDetails = JSON.parse(errorText);
+            const errorMessage = Array.isArray(errorDetails) && errorDetails.length > 0 ? errorDetails[0].message : errorText;
+            const message = `Cannot delete asset ${assetId}: ${errorMessage}`;
+            throw new AssetValidationError(message, assetId, "delete", "agreements", {
+              apiResponse: errorDetails
+            });
+          } catch (parseError) {
+            if (parseError instanceof AssetValidationError) {
+              throw parseError;
+            }
+            const message = `Cannot delete asset ${assetId}: ${errorText}`;
+            throw new AssetValidationError(message, assetId, "delete", "agreements", {
+              rawError: errorText
+            });
+          }
+        }
         throw new Error(`Failed to delete asset: ${response.status} ${response.statusText} - ${errorText}`);
       }
       await this.cache.delete(assetId);
+      this.assetAgreements.delete(assetId);
       return true;
     }
     async getAllPolicies(querySpec) {
@@ -1203,29 +1389,352 @@ let __tla = (async () => {
     getExpandedPredicate(property, _context) {
       return property;
     }
-  }
-  const _DataspaceConnectorStoreAdapter = class _DataspaceConnectorStoreAdapter {
+  };
+  __publicField(_DataspaceConnectorStore, "AUTO_NEGOTIATED_CONTRACT_KEY", "__autoNegotiatedContract");
+  let DataspaceConnectorStore = _DataspaceConnectorStore;
+  class DataspaceConnectorStoreAdapter {
     constructor() {
     }
     static getStoreInstance(cfg) {
-      if (!_DataspaceConnectorStoreAdapter.store) {
-        if (!cfg) {
-          throw new Error("DataspaceConnectorStore configuration is required");
+      var _a2;
+      if (!cfg) {
+        throw new Error("DataspaceConnectorStore configuration is required");
+      }
+      const dspConfig = cfg;
+      console.log("\u{1F3ED} [DataspaceConnectorStoreAdapter.getStoreInstance] Creating new store with config:", {
+        endpoint: dspConfig.endpoint,
+        catalogEndpoint: dspConfig.catalogEndpoint,
+        negotiationEndpoint: dspConfig.contractNegotiationEndpoint
+      });
+      const newStore = new DataspaceConnectorStore(dspConfig);
+      console.log("\u2705 [DataspaceConnectorStoreAdapter.getStoreInstance] Created store:", {
+        storeType: typeof newStore,
+        configEndpoint: (_a2 = newStore.config) == null ? void 0 : _a2.endpoint
+      });
+      return newStore;
+    }
+  }
+  DEFAULT_AUTH_SELECTORS = [
+    "sib-auth-oidc",
+    "sib-auth"
+  ];
+  function findAuthElement(selectors = [
+    ...DEFAULT_AUTH_SELECTORS
+  ]) {
+    for (const selector of selectors) {
+      const element = document.querySelector(selector);
+      if (element && typeof element.getFetch === "function") {
+        return element;
+      }
+    }
+    return null;
+  }
+  function getAuthFetch(selectors) {
+    const authElement = findAuthElement(selectors);
+    if (authElement) {
+      try {
+        const authFetch = authElement.getFetch();
+        if (typeof authFetch === "function") {
+          return authFetch;
         }
-        _DataspaceConnectorStoreAdapter.store = new DataspaceConnectorStore(cfg);
+      } catch (error2) {
+        console.warn("[AuthFetchResolver] Error getting auth fetch:", error2);
       }
-      return _DataspaceConnectorStoreAdapter.store;
     }
+    return fetch.bind(globalThis);
+  }
+  function onAuthActivated(callback, eventName = "sib-auth:activated") {
+    const handler2 = (event) => {
+      var _a2;
+      if (((_a2 = event.detail) == null ? void 0 : _a2.fetch) && typeof event.detail.fetch === "function") {
+        callback(event);
+      }
+    };
+    document.addEventListener(eventName, handler2);
+    return () => {
+      document.removeEventListener(eventName, handler2);
+    };
+  }
+  async function waitForAuthElement(selectors = [
+    ...DEFAULT_AUTH_SELECTORS
+  ], timeout = 5e3) {
+    const existing = findAuthElement(selectors);
+    if (existing) {
+      return existing;
+    }
+    return new Promise((resolve, reject) => {
+      const observer = new MutationObserver(() => {
+        const element = findAuthElement(selectors);
+        if (element) {
+          observer.disconnect();
+          resolve(element);
+        }
+      });
+      observer.observe(document.body, {
+        childList: true,
+        subtree: true
+      });
+      setTimeout(() => {
+        observer.disconnect();
+        reject(new Error(`No auth element found with selectors: ${selectors.join(", ")}`));
+      }, timeout);
+    });
+  }
+  AuthFetchResolver = {
+    findAuthElement,
+    getAuthFetch,
+    onAuthActivated,
+    waitForAuthElement
   };
-  __publicField(_DataspaceConnectorStoreAdapter, "store");
-  let DataspaceConnectorStoreAdapter = _DataspaceConnectorStoreAdapter;
+  const _LocalStorageCacheMetadataManager = class _LocalStorageCacheMetadataManager {
+    constructor(endpoint, ttlMs = _LocalStorageCacheMetadataManager.DEFAULT_TTL_MS) {
+      this.endpoint = endpoint;
+      this.ttlMs = ttlMs;
+      this.cleanupOldCacheFormat();
+    }
+    cleanupOldCacheFormat() {
+      try {
+        const endpointHash = this.endpoint.replace(/[^a-zA-Z0-9]/g, "");
+        const oldKey = `fc-cache-meta-${endpointHash}`;
+        if (localStorage.getItem(oldKey)) {
+          localStorage.removeItem(oldKey);
+        }
+      } catch (error2) {
+        console.warn("[LocalStorageCache] Error cleaning up old cache format:", error2);
+      }
+    }
+    getStorageKey() {
+      const endpointHash = this.endpoint.replace(/[^a-zA-Z0-9]/g, "");
+      return `${_LocalStorageCacheMetadataManager.STORAGE_KEY_PREFIX}-${endpointHash}`;
+    }
+    getCacheData() {
+      try {
+        const key = this.getStorageKey();
+        const data = localStorage.getItem(key);
+        if (!data) {
+          return null;
+        }
+        const parsed = JSON.parse(data);
+        const items = /* @__PURE__ */ new Map();
+        if (parsed.items) {
+          for (const [hash, metadata] of Object.entries(parsed.items)) {
+            items.set(hash, metadata);
+          }
+        }
+        return {
+          version: parsed.version,
+          lastFetchTimestamp: parsed.lastFetchTimestamp,
+          cacheExpirationTimestamp: parsed.cacheExpirationTimestamp,
+          resource: parsed.resource,
+          items
+        };
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error reading cache data:", error2);
+        return null;
+      }
+    }
+    getCacheMetadata() {
+      return this.getCacheData();
+    }
+    setCacheData(cacheData) {
+      try {
+        const key = this.getStorageKey();
+        const itemsObj = {};
+        cacheData.items.forEach((value, hash) => {
+          itemsObj[hash] = value;
+        });
+        const data = JSON.stringify({
+          version: cacheData.version,
+          lastFetchTimestamp: cacheData.lastFetchTimestamp,
+          cacheExpirationTimestamp: cacheData.cacheExpirationTimestamp,
+          resource: cacheData.resource,
+          items: itemsObj
+        });
+        localStorage.setItem(key, data);
+        return true;
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error writing cache data:", error2);
+        return false;
+      }
+    }
+    setCacheMetadata(cacheData) {
+      return this.setCacheData(cacheData);
+    }
+    isCacheValid() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return false;
+      }
+      if (cacheData.version !== _LocalStorageCacheMetadataManager.CACHE_VERSION) {
+        console.log("[LocalStorageCache] Cache version mismatch, invalidating");
+        return false;
+      }
+      const now = Date.now();
+      if (now > cacheData.cacheExpirationTimestamp) {
+        console.log("[LocalStorageCache] Cache TTL expired");
+        return false;
+      }
+      return true;
+    }
+    getResource() {
+      const cacheData = this.getCacheData();
+      return (cacheData == null ? void 0 : cacheData.resource) || null;
+    }
+    getKnownHashes() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return /* @__PURE__ */ new Set();
+      }
+      return new Set(cacheData.items.keys());
+    }
+    getItemMetadata(sdHash) {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return null;
+      }
+      return cacheData.items.get(sdHash) || null;
+    }
+    updateCache(resource, items) {
+      const now = Date.now();
+      let cacheData = this.getCacheData();
+      if (!cacheData || !this.isCacheValid()) {
+        cacheData = {
+          version: _LocalStorageCacheMetadataManager.CACHE_VERSION,
+          lastFetchTimestamp: now,
+          cacheExpirationTimestamp: now + this.ttlMs,
+          resource,
+          items: /* @__PURE__ */ new Map()
+        };
+      } else {
+        cacheData.resource = resource;
+      }
+      for (const item of items) {
+        cacheData.items.set(item.sdHash, {
+          ...item,
+          cachedAt: now
+        });
+      }
+      cacheData.lastFetchTimestamp = now;
+      return this.setCacheData(cacheData);
+    }
+    removeItems(sdHashes) {
+      var _a2;
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return false;
+      }
+      for (const hash of sdHashes) {
+        cacheData.items.delete(hash);
+      }
+      if ((_a2 = cacheData.resource) == null ? void 0 : _a2["ldp:contains"]) {
+        const resourceIdsToRemove = /* @__PURE__ */ new Set();
+        for (const hash of sdHashes) {
+          const meta = cacheData.items.get(hash);
+          if (meta) {
+            resourceIdsToRemove.add(meta.resourceId);
+          }
+        }
+        cacheData.resource["ldp:contains"] = cacheData.resource["ldp:contains"].filter((item) => !resourceIdsToRemove.has(item["@id"]));
+      }
+      return this.setCacheData(cacheData);
+    }
+    clear() {
+      try {
+        const key = this.getStorageKey();
+        localStorage.removeItem(key);
+        return true;
+      } catch (error2) {
+        console.error("[LocalStorageCache] Error clearing cache data:", error2);
+        return false;
+      }
+    }
+    getCacheStats() {
+      const cacheData = this.getCacheData();
+      if (!cacheData) {
+        return {
+          itemCount: 0,
+          lastFetch: null,
+          expiresAt: null,
+          isValid: false
+        };
+      }
+      return {
+        itemCount: cacheData.items.size,
+        lastFetch: new Date(cacheData.lastFetchTimestamp),
+        expiresAt: new Date(cacheData.cacheExpirationTimestamp),
+        isValid: this.isCacheValid()
+      };
+    }
+  };
+  __publicField(_LocalStorageCacheMetadataManager, "STORAGE_KEY_PREFIX", "fc-cache-data");
+  __publicField(_LocalStorageCacheMetadataManager, "CACHE_VERSION", "2.0.0");
+  __publicField(_LocalStorageCacheMetadataManager, "DEFAULT_TTL_MS", 2 * 60 * 60 * 1e3);
+  let LocalStorageCacheMetadataManager = _LocalStorageCacheMetadataManager;
   class FederatedCatalogueAPIWrapper {
-    constructor(options, fcBaseUrl) {
+    constructor(options, fcBaseUrl, fetchAuth) {
       __publicField(this, "fcBaseUrl");
-      __publicField(this, "connect");
+      __publicField(this, "loginOptions");
+      __publicField(this, "tokenState", null);
+      __publicField(this, "tokenRefreshBuffer", 5 * 60 * 1e3);
+      __publicField(this, "isRefreshing", false);
+      __publicField(this, "refreshPromise", null);
+      __publicField(this, "STORAGE_KEY", "fc_token_state");
+      __publicField(this, "_fetch");
+      __publicField(this, "useKeycloakAuth");
       this.fcBaseUrl = fcBaseUrl;
-      const connection = this.firstConnect(options);
-      this.connect = () => connection;
+      this.loginOptions = options;
+      if (fetchAuth && (!options.kc_url || options.kc_url === "")) {
+        this._fetch = fetchAuth;
+        this.useKeycloakAuth = false;
+      } else {
+        this._fetch = fetch.bind(globalThis);
+        this.useKeycloakAuth = true;
+        this.loadTokenState();
+      }
+      if (this.useKeycloakAuth) {
+        try {
+          this.firstConnect(options);
+        } catch (e) {
+          console.log("Error while establishing the first connection", e);
+        }
+      }
+    }
+    saveTokenState() {
+      if (this.tokenState) {
+        try {
+          localStorage.setItem(this.STORAGE_KEY, JSON.stringify(this.tokenState));
+          console.log("\u{1F4BE} [FederatedCatalogueAPIWrapper] Token state saved to localStorage");
+        } catch (error2) {
+          console.error("Failed to save token state to localStorage:", error2);
+        }
+      }
+    }
+    loadTokenState() {
+      var _a2, _b, _c;
+      try {
+        const stored = localStorage.getItem(this.STORAGE_KEY);
+        if (stored) {
+          this.tokenState = JSON.parse(stored);
+          console.log("\u{1F4C2} [FederatedCatalogueAPIWrapper] Token state loaded from localStorage:", {
+            hasAccessToken: !!((_a2 = this.tokenState) == null ? void 0 : _a2.access_token),
+            hasRefreshToken: !!((_b = this.tokenState) == null ? void 0 : _b.refresh_token),
+            expiresAt: (_c = this.tokenState) == null ? void 0 : _c.expires_at,
+            isExpired: this.tokenState ? Date.now() >= this.tokenState.expires_at : "N/A"
+          });
+        }
+      } catch (error2) {
+        console.error("Failed to load token state from localStorage:", error2);
+        this.clearTokenState();
+      }
+    }
+    clearTokenState() {
+      this.tokenState = null;
+      try {
+        localStorage.removeItem(this.STORAGE_KEY);
+        console.log("\u{1F5D1}\uFE0F [FederatedCatalogueAPIWrapper] Token state cleared");
+      } catch (error2) {
+        console.error("Failed to clear token state from localStorage:", error2);
+      }
     }
     async firstConnect(options) {
       const body = new URLSearchParams({
@@ -1239,7 +1748,7 @@ let __tla = (async () => {
       const headers = new Headers({
         "Content-Type": "application/x-www-form-urlencoded"
       });
-      const response = await fetch(options.kc_url, {
+      const response = await this._fetch(options.kc_url, {
         method: "POST",
         headers,
         body
@@ -1251,28 +1760,130 @@ let __tla = (async () => {
           cause: data
         });
       }
+      this.tokenState = {
+        access_token: token,
+        refresh_token: data.refresh_token || null,
+        expires_at: Date.now() + (data.expires_in || 3600) * 1e3
+      };
+      this.saveTokenState();
       return token;
     }
-    async getAllSelfDescriptions() {
-      const token = await this.connect();
-      const url2 = `${this.fcBaseUrl}/self-descriptions`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`
-      });
-      const response = await fetch(url2, {
+    async refreshToken() {
+      if (this.isRefreshing && this.refreshPromise) {
+        return this.refreshPromise;
+      }
+      this.isRefreshing = true;
+      this.refreshPromise = this._performRefresh();
+      try {
+        const token = await this.refreshPromise;
+        return token;
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    }
+    async _performRefresh() {
+      var _a2;
+      if (!((_a2 = this.tokenState) == null ? void 0 : _a2.refresh_token)) {
+        console.log("No refresh token available, re-authenticating with credentials");
+        return this.firstConnect(this.loginOptions);
+      }
+      try {
+        const body = new URLSearchParams({
+          grant_type: "refresh_token",
+          client_id: this.loginOptions.kc_client_id,
+          client_secret: this.loginOptions.kc_client_secret,
+          refresh_token: this.tokenState.refresh_token
+        });
+        const headers = new Headers({
+          "Content-Type": "application/x-www-form-urlencoded"
+        });
+        const response = await this._fetch(this.loginOptions.kc_url, {
+          method: "POST",
+          headers,
+          body
+        });
+        if (!response.ok) {
+          console.warn("Token refresh failed, re-authenticating with credentials");
+          return this.firstConnect(this.loginOptions);
+        }
+        const data = await response.json();
+        const token = data.access_token;
+        if (token == null) {
+          throw new Error("Token refresh failed: no access_token in response", {
+            cause: data
+          });
+        }
+        this.tokenState = {
+          access_token: token,
+          refresh_token: data.refresh_token || this.tokenState.refresh_token,
+          expires_at: Date.now() + (data.expires_in || 3600) * 1e3
+        };
+        this.saveTokenState();
+        return token;
+      } catch (error2) {
+        console.error("Error refreshing token:", error2);
+        this.clearTokenState();
+        return this.firstConnect(this.loginOptions);
+      }
+    }
+    async getValidToken() {
+      if (!this.tokenState) {
+        return await this.firstConnect(this.loginOptions);
+      }
+      const now = Date.now();
+      const isExpiringSoon = now >= this.tokenState.expires_at - this.tokenRefreshBuffer;
+      if (isExpiringSoon) {
+        return await this.refreshToken();
+      }
+      return this.tokenState.access_token;
+    }
+    async fetchWithAuth(url2, options = {}) {
+      var _a2;
+      if (!this.useKeycloakAuth) {
+        return this._fetch(url2, options);
+      }
+      const token = await this.getValidToken();
+      const headers = new Headers(options.headers);
+      headers.set("Authorization", `Bearer ${token}`);
+      let response = await this._fetch(url2, {
+        ...options,
         headers
       });
+      if (response.status === 401 || response.status === 403) {
+        console.log(`\u{1F510} [FederatedCatalogueAPIWrapper] Authentication failed (${response.status}) for ${url2}`);
+        console.log("\u{1F504} [FederatedCatalogueAPIWrapper] Attempting token refresh...", {
+          hasRefreshToken: !!((_a2 = this.tokenState) == null ? void 0 : _a2.refresh_token),
+          tokenExpired: this.tokenState ? Date.now() >= this.tokenState.expires_at : "N/A"
+        });
+        try {
+          const newToken = await this.refreshToken();
+          console.log("\u2705 [FederatedCatalogueAPIWrapper] Token refreshed successfully, retrying request...");
+          headers.set("Authorization", `Bearer ${newToken}`);
+          response = await this._fetch(url2, {
+            ...options,
+            headers
+          });
+          if (response.status === 401 || response.status === 403) {
+            console.error(`\u274C [FederatedCatalogueAPIWrapper] Authentication still failed after token refresh (${response.status}). Please check credentials.`);
+          } else {
+            console.log(`\u2705 [FederatedCatalogueAPIWrapper] Retry succeeded with status ${response.status}`);
+          }
+        } catch (error2) {
+          console.error("\u274C [FederatedCatalogueAPIWrapper] Failed to refresh token:", error2);
+        }
+      }
+      return response;
+    }
+    async getAllSelfDescriptions() {
+      const url2 = `${this.fcBaseUrl}/self-descriptions`;
+      const response = await this.fetchWithAuth(url2);
       return await response.json();
     }
     async getSelfDescriptionByHash(sdHash) {
-      const token = await this.connect();
       const url2 = `${this.fcBaseUrl}/self-descriptions/${sdHash}`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`
-      });
-      const response = await fetch(url2, {
-        method: "GET",
-        headers
+      const response = await this.fetchWithAuth(url2, {
+        method: "GET"
       });
       if (!response.ok) throw new Error(`GET /self-descriptions/${sdHash} failed: ${response.status} ${response.statusText}`, {
         cause: response
@@ -1280,19 +1891,16 @@ let __tla = (async () => {
       return await response.json();
     }
     async postQuery(statement, parameters = {}) {
-      const token = await this.connect();
       const url2 = `${this.fcBaseUrl}/query`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      });
       const body = JSON.stringify({
         statement,
         parameters
       });
-      const response = await fetch(url2, {
+      const response = await this.fetchWithAuth(url2, {
         method: "POST",
-        headers,
+        headers: {
+          "Content-Type": "application/json"
+        },
         body
       });
       if (!response.ok) {
@@ -1303,12 +1911,7 @@ let __tla = (async () => {
       return await response.json();
     }
     async postQuerySearch(statement, parameters = {}, queryLanguage = "OPENCYPHER", annotations) {
-      const token = await this.connect();
       const url2 = `${this.fcBaseUrl}/query/search`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      });
       const body = JSON.stringify({
         statement,
         parameters,
@@ -1316,9 +1919,11 @@ let __tla = (async () => {
           queryLanguage
         }
       });
-      const response = await fetch(url2, {
+      const response = await this.fetchWithAuth(url2, {
         method: "POST",
-        headers,
+        headers: {
+          "Content-Type": "application/json"
+        },
         body
       });
       if (!response.ok) {
@@ -1329,55 +1934,272 @@ let __tla = (async () => {
       return await response.json();
     }
   }
-  function getFederatedCatalogueAPIWrapper(baseUrl, optionLogin, optionsServer) {
-    const options = Object.assign({}, optionsServer, optionLogin);
-    return new FederatedCatalogueAPIWrapper(options, baseUrl);
+  function getFederatedCatalogueAPIWrapper(baseUrl, loginOptions, fetch2) {
+    return new FederatedCatalogueAPIWrapper(loginOptions, baseUrl, fetch2);
   }
   class FederatedCatalogueStore {
     constructor(cfg) {
       __publicField(this, "cache");
-      __publicField(this, "session");
       __publicField(this, "fcApi");
+      __publicField(this, "metadataManager");
+      __publicField(this, "enableCaching");
+      __publicField(this, "cleanupAuth");
+      __publicField(this, "isFetching", false);
+      __publicField(this, "pendingGetData", null);
+      __publicField(this, "resolveFetch", (event) => {
+        if (!this.cfg.endpoint) {
+          throw new Error("Missing required `endpoint` in StoreConfig for FederatedCatalogueStore");
+        }
+        if (event.detail.fetch) {
+          this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, event.detail.fetch);
+        }
+      });
       this.cfg = cfg;
-      if (!this.cfg.login) {
-        throw new Error("Login must be provided for FederatedCatalogueStore");
-      }
       if (!this.cfg.endpoint) {
         throw new Error("Missing required `endpoint` in StoreConfig for FederatedCatalogueStore");
       }
-      if (!this.cfg.optionsServer) {
-        throw new Error("Missing required `optionsServer` in StoreConfig for FederatedCatalogueStore");
+      const fetchAuth = AuthFetchResolver.getAuthFetch();
+      this.cleanupAuth = AuthFetchResolver.onAuthActivated(this.resolveFetch.bind(this));
+      if (fetchAuth && !this.cfg.login) {
+        this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, {}, fetchAuth);
+      } else {
+        this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, this.cfg.login, fetchAuth);
       }
-      this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, this.cfg.login, this.cfg.optionsServer);
       this.cache = new InMemoryCacheManager();
+      this.enableCaching = this.cfg.enableLocalStorageMetadata === true;
+      if (this.enableCaching && this.cfg.endpoint) {
+        const cacheTTL = this.cfg.cacheTTL || 2 * 60 * 60 * 1e3;
+        this.metadataManager = new LocalStorageCacheMetadataManager(this.cfg.endpoint, cacheTTL);
+        this.handlePageReload();
+      } else {
+        this.metadataManager = null;
+      }
+    }
+    disconnectedCallback() {
+      var _a2;
+      (_a2 = this.cleanupAuth) == null ? void 0 : _a2.call(this);
+    }
+    handlePageReload() {
+      var _a2, _b;
+      try {
+        const SESSION_KEY = "fc-session-id";
+        let sessionId = sessionStorage.getItem(SESSION_KEY);
+        if (!sessionId) {
+          sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+          sessionStorage.setItem(SESSION_KEY, sessionId);
+          (_a2 = this.metadataManager) == null ? void 0 : _a2.clear();
+        }
+        const stats = (_b = this.metadataManager) == null ? void 0 : _b.getCacheStats();
+        if (stats) {
+        }
+      } catch (error2) {
+        console.warn("[FederatedCatalogueStore] Error handling page reload:", error2);
+      }
+    }
+    resolveTargetType(args) {
+      if (typeof args === "string") return args;
+      if (typeof args === "object" && args !== null) {
+        return args.targetType ?? args.id ?? "";
+      }
+      return "";
+    }
+    buildContainerId(containerType = "default") {
+      var _a2;
+      const endpointHash = ((_a2 = this.cfg.endpoint) == null ? void 0 : _a2.replace(/[^a-zA-Z0-9]/g, "")) || "unknown";
+      return `store://local.fc-${endpointHash}-${containerType}/`;
     }
     async getData(args) {
-      const targetType = "targetType" in args ? args.targetType : args.id;
+      if (this.isFetching) {
+        if (this.pendingGetData) {
+          return this.pendingGetData;
+        }
+        return null;
+      }
+      this.isFetching = true;
+      const executeGetData = async () => {
+        var _a2;
+        const targetType = this.resolveTargetType(args);
+        if (!this.fcApi) {
+          throw new Error("Federated API not initialized, returning empty data.");
+        }
+        const cacheIsValid = this.enableCaching && ((_a2 = this.metadataManager) == null ? void 0 : _a2.isCacheValid());
+        const hasCached = this.hasCachedData();
+        if (cacheIsValid && hasCached) {
+          return await this.getDeltaUpdatedData(targetType);
+        }
+        if (cacheIsValid && !hasCached && this.metadataManager) {
+          this.metadataManager.clear();
+        }
+        return await this.getFullData(targetType);
+      };
+      this.pendingGetData = executeGetData().finally(() => {
+        this.isFetching = false;
+        this.pendingGetData = null;
+      });
+      return this.pendingGetData;
+    }
+    hasCachedData() {
+      try {
+        if (!this.metadataManager) {
+          return false;
+        }
+        const resource = this.metadataManager.getResource();
+        const hasResourceData = !!((resource == null ? void 0 : resource["ldp:contains"]) && resource["ldp:contains"].length > 0);
+        const metadataItemCount = this.metadataManager.getCacheStats().itemCount || 0;
+        return hasResourceData && metadataItemCount > 0;
+      } catch (error2) {
+        console.error("[FederatedCatalogueStore] Error checking cached data:", error2);
+        return false;
+      }
+    }
+    async getDeltaUpdatedData(targetType) {
+      if (!this.fcApi || !this.metadataManager) {
+        return await this.getFullData(targetType);
+      }
+      try {
+        const apiList = await this.fcApi.getAllSelfDescriptions();
+        if (!apiList || !apiList.items) {
+          console.warn("[FederatedCatalogueStore] No items returned from API");
+          return await this.getFullData(targetType);
+        }
+        const resource = this.metadataManager.getResource();
+        if (!resource) {
+          return await this.getFullData(targetType);
+        }
+        if (!resource["@id"]) {
+          resource["@id"] = this.buildContainerId();
+        }
+        if (!resource["ldp:contains"]) {
+          resource["ldp:contains"] = [];
+        }
+        const knownHashes = this.metadataManager.getKnownHashes();
+        const items = (apiList == null ? void 0 : apiList.items) || [];
+        if (!Array.isArray(items)) {
+          console.warn("[FederatedCatalogueStore] apiList.items is not an array");
+          return resource;
+        }
+        const apiHashes = new Set(items.map((item) => item.meta.sdHash));
+        const newHashes = [];
+        const updatedHashes = [];
+        const deletedHashes = [];
+        for (const item of items) {
+          const hash = item.meta.sdHash;
+          if (!knownHashes.has(hash)) {
+            newHashes.push(hash);
+          } else {
+            const cachedMeta = this.metadataManager.getItemMetadata(hash);
+            if (cachedMeta) {
+              if (item.meta.uploadDatetime > cachedMeta.uploadDatetime || item.meta.statusDatetime > cachedMeta.statusDatetime) {
+                updatedHashes.push(hash);
+              }
+            }
+          }
+        }
+        for (const hash of knownHashes) {
+          if (!apiHashes.has(hash)) {
+            deletedHashes.push(hash);
+          }
+        }
+        const toFetch = [
+          ...newHashes,
+          ...updatedHashes
+        ];
+        const newMetadata = [];
+        if (toFetch.length > 0) {
+          for (const hash of toFetch) {
+            try {
+              const sd = await this.fcApi.getSelfDescriptionByHash(hash);
+              if (sd) {
+                const mappedResource = this.mapSourceToDestination(sd, {
+                  temsServiceBase: this.cfg.temsServiceBase,
+                  temsCategoryBase: this.cfg.temsCategoryBase,
+                  temsImageBase: this.cfg.temsImageBase,
+                  temsProviderBase: this.cfg.temsProviderBase
+                });
+                if (updatedHashes.includes(hash)) {
+                  const index = resource["ldp:contains"].findIndex((r) => r["@id"] === mappedResource["@id"]);
+                  if (index !== -1) {
+                    resource["ldp:contains"].splice(index, 1);
+                  }
+                }
+                resource["ldp:contains"].push(mappedResource);
+                const apiItem = apiList.items.find((i) => i.meta.sdHash === hash);
+                if (apiItem) {
+                  newMetadata.push({
+                    sdHash: hash,
+                    uploadDatetime: apiItem.meta.uploadDatetime,
+                    statusDatetime: apiItem.meta.statusDatetime,
+                    cachedAt: Date.now(),
+                    resourceId: mappedResource["@id"]
+                  });
+                }
+              }
+            } catch (error2) {
+              console.error(`[FederatedCatalogueStore] Error fetching hash ${hash}:`, error2);
+            }
+          }
+        }
+        if (deletedHashes.length > 0) {
+          this.metadataManager.removeItems(deletedHashes);
+        }
+        if (newMetadata.length > 0) {
+          this.metadataManager.updateCache(resource, newMetadata);
+        }
+        document.dispatchEvent(new CustomEvent("save", {
+          detail: {
+            resource: {
+              "@id": resource == null ? void 0 : resource["@id"]
+            }
+          },
+          bubbles: true
+        }));
+        return resource;
+      } catch (error2) {
+        console.error("[FederatedCatalogueStore] Delta update failed, falling back to full fetch:", error2);
+        return await this.getFullData(targetType);
+      }
+    }
+    async getFullData(_targetType) {
       if (!this.fcApi) {
-        throw new Error("Federated API not initialized, returning empty data.");
-      }
-      let resource = await this.get(targetType);
-      if (!resource || resource["ldp:contains"].length === 0) {
-        resource = await this.initLocalDataSourceContainer(targetType);
-        const dataset2 = await this.fcApi.getAllSelfDescriptions();
-        for (const item in dataset2.items) {
-          const sd = await this.fcApi.getSelfDescriptionByHash(dataset2.items[item].meta.sdHash);
+        throw new Error("Federated API not initialized");
+      }
+      const resource = await this.initLocalDataSourceContainer();
+      const dataset2 = await this.fcApi.getAllSelfDescriptions();
+      const newMetadata = [];
+      if ((dataset2 == null ? void 0 : dataset2.items) && Array.isArray(dataset2.items)) {
+        for (const item of dataset2.items) {
+          const sd = await this.fcApi.getSelfDescriptionByHash(item.meta.sdHash);
           if (sd) {
-            const mappedResource = this.mapSourceToDestination(sd, {
-              temsServiceBase: this.cfg.temsServiceBase,
-              temsCategoryBase: this.cfg.temsCategoryBase,
-              temsImageBase: this.cfg.temsImageBase,
-              temsProviderBase: this.cfg.temsProviderBase
-            });
-            resource["ldp:contains"].push(mappedResource);
+            try {
+              const mappedResource = this.mapSourceToDestination(sd, {
+                temsServiceBase: this.cfg.temsServiceBase,
+                temsCategoryBase: this.cfg.temsCategoryBase,
+                temsImageBase: this.cfg.temsImageBase,
+                temsProviderBase: this.cfg.temsProviderBase
+              });
+              resource["ldp:contains"].push(mappedResource);
+              if (this.enableCaching) {
+                newMetadata.push({
+                  sdHash: item.meta.sdHash,
+                  uploadDatetime: item.meta.uploadDatetime,
+                  statusDatetime: item.meta.statusDatetime,
+                  cachedAt: Date.now(),
+                  resourceId: mappedResource["@id"]
+                });
+              }
+            } catch (error2) {
+              console.error("[FederatedCatalogueStore] Error mapping resource:", error2);
+            }
           }
         }
-        this.setLocalData(resource, targetType);
+      }
+      if (this.enableCaching && this.metadataManager && newMetadata.length > 0) {
+        this.metadataManager.updateCache(resource, newMetadata);
       }
       document.dispatchEvent(new CustomEvent("save", {
         detail: {
           resource: {
-            "@id": resource["@id"]
+            "@id": resource == null ? void 0 : resource["@id"]
           }
         },
         bubbles: true
@@ -1385,11 +2207,8 @@ let __tla = (async () => {
       return resource;
     }
     async initLocalDataSourceContainer(dataSrc = "", containerType = "default") {
-      var _a2;
-      const endpointHash = ((_a2 = this.cfg.endpoint) == null ? void 0 : _a2.replace(/[^a-zA-Z0-9]/g, "")) || "unknown";
-      const idField = `fc-${endpointHash}-${containerType}`;
       if (!dataSrc) {
-        dataSrc = `store://local.${idField}/`;
+        dataSrc = this.buildContainerId(containerType);
       }
       const localContainer = {
         "@context": "https://cdn.startinblox.com/owl/context.jsonld",
@@ -1450,10 +2269,10 @@ let __tla = (async () => {
     }
     subscribeResourceTo(_resourceId, _nestedResourceId) {
     }
-    fetchAuthn(_iri, _options) {
-      return Promise.resolve({});
+    async fetchAuthn(_iri, _options) {
+      return await Promise.resolve({});
     }
-    async setLocalData(resource, id, _skipFetch) {
+    async setLocalData(resource, id) {
       try {
         const resourceWithId = {
           ...resource,
@@ -1477,8 +2296,39 @@ let __tla = (async () => {
         bubbles: true
       }));
     }
+    stripUrnPrefix(id, prefix) {
+      if (id == null ? void 0 : id.startsWith(prefix)) {
+        return id.substring(prefix.length);
+      }
+      return id;
+    }
+    stripTemsUrnFromPolicy(obj) {
+      if (obj === null || obj === void 0) {
+        return obj;
+      }
+      if (typeof obj === "string") {
+        return this.stripUrnPrefix(obj, "urn:tems:");
+      }
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.stripTemsUrnFromPolicy(item));
+      }
+      if (typeof obj === "object") {
+        const result = {};
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (key === "@id") {
+              result[key] = this.stripUrnPrefix(obj[key], "urn:tems:");
+            } else {
+              result[key] = this.stripTemsUrnFromPolicy(obj[key]);
+            }
+          }
+        }
+        return result;
+      }
+      return obj;
+    }
     mapSourceToDestination(src, opts) {
-      var _a2, _b, _c, _d, _e, _f, _g, _h;
+      var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       const vc = src.verifiableCredential;
       const cs = vc.credentialSubject;
       let catInfo;
@@ -1489,9 +2339,16 @@ let __tla = (async () => {
         usedKey = "service";
         type = "tems:Service";
       } else if (cs["dcat:dataset"] && cs["dcat:dataset"].length > 0) {
-        catInfo = cs["dcat:dataset"][0];
-        usedKey = "dataset";
-        type = "tems:DataOffer";
+        const dataset2 = cs["dcat:dataset"][0];
+        if (dataset2["dcat:service"]) {
+          catInfo = dataset2["dcat:service"];
+          usedKey = "nested-service";
+          type = "tems:Service";
+        } else {
+          catInfo = dataset2;
+          usedKey = "dataset";
+          type = "tems:DataOffer";
+        }
       } else {
         throw new Error("Expected either credentialSubject['dcat:service'] or a non-empty array in ['dcat:dataset']");
       }
@@ -1500,7 +2357,7 @@ let __tla = (async () => {
       const serviceId = `${opts.temsServiceBase}${encodeURIComponent(slug)}/`;
       const creation_date = vc.issuanceDate;
       const update_date = vc.expirationDate;
-      const name = catInfo["dcterms:title"];
+      const name = catInfo["dcterms:title"] || catInfo["dct:title"];
       const description = catInfo["rdfs:comment"];
       const keywords = catInfo["dcat:keyword"] || [];
       const long_description = keywords.length > 0 ? `Keywords: ${keywords.join(", ")}` : "";
@@ -1540,19 +2397,24 @@ let __tla = (async () => {
       const contact_url = catInfo["dcat:endpointDescription"] || "";
       const documentation_url = contact_url || "";
       let service_url = catInfo["dcat:endpointURL"] || "";
+      if (!service_url) {
+        console.warn("[FederatedCatalogueStore] dcat:endpointURL is missing from dcat:service. Available fields:", Object.keys(catInfo));
+      }
       if (service_url.includes("demo.isan.org")) service_url = new URL(service_url).origin;
       let providerRef;
       if (usedKey === "service") {
         providerRef = ((_d = cs["gax-core:operatedBy"]) == null ? void 0 : _d["@id"]) || "";
+      } else if (usedKey === "nested-service") {
+        providerRef = ((_e = cs["gax-core:operatedBy"]) == null ? void 0 : _e["@id"]) || ((_f = cs["gax-core:offeredBy"]) == null ? void 0 : _f["@id"]) || "";
       } else {
-        providerRef = ((_e = cs["gax-core:offeredBy"]) == null ? void 0 : _e["@id"]) || "";
+        providerRef = ((_g = cs["gax-core:offeredBy"]) == null ? void 0 : _g["@id"]) || "";
       }
       const providerSlug = providerRef.split(":").pop() + String(Math.random()) || "0";
-      const providerLogo = ((_g = (_f = catInfo["dcterms:creator"]) == null ? void 0 : _f["foaf:thumbnail"]) == null ? void 0 : _g["rdf:resource"]) || "";
+      const providerLogo = ((_i = (_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:thumbnail"]) == null ? void 0 : _i["rdf:resource"]) || "";
       const provider = {
         "@id": `${opts.temsProviderBase}${encodeURIComponent(providerSlug)}/`,
         "@type": "tems:Provider",
-        name: ((_h = catInfo["dcterms:creator"]) == null ? void 0 : _h["foaf:name"]) || "",
+        name: ((_j = catInfo["dcterms:creator"]) == null ? void 0 : _j["foaf:name"]) || "",
         image: {
           "@id": `${opts.temsImageBase}${encodeURIComponent(providerLogo.split("/").pop() || "0")}/`,
           "@type": "tems:Image",
@@ -1562,6 +2424,49 @@ let __tla = (async () => {
         }
       };
       const data_offers = [];
+      const counterPartyAddress = cs["dcat:endpointURL"];
+      const counterPartyId = cs["dspace:participantId"];
+      const assetId = this.stripUrnPrefix(cs["@id"], "urn:uuid:");
+      let datasetId;
+      let policy;
+      let policies = [];
+      if (cs["dcat:dataset"] && cs["dcat:dataset"].length > 0) {
+        const dataset2 = cs["dcat:dataset"][0];
+        if (dataset2["@id"]) {
+          datasetId = this.stripUrnPrefix(dataset2["@id"], "urn:uuid:");
+        }
+        if (dataset2["odrl:hasPolicy"]) {
+          const rawPolicy = dataset2["odrl:hasPolicy"];
+          const processSinglePolicy = (policyObj) => {
+            const processedPolicy = this.stripTemsUrnFromPolicy(JSON.parse(JSON.stringify(policyObj)));
+            if (datasetId) {
+              processedPolicy.target = datasetId;
+            }
+            return processedPolicy;
+          };
+          if (Array.isArray(rawPolicy)) {
+            policies = rawPolicy.map(processSinglePolicy);
+            policy = policies[0];
+          } else {
+            policy = processSinglePolicy(rawPolicy);
+            policies = [
+              policy
+            ];
+          }
+        }
+      }
+      console.log("[FederatedCatalogueStore] \u{1F50D} Policy processing for", name, ":", {
+        hasPolicy: !!policy,
+        policiesCount: policies.length,
+        policy: policy ? {
+          "@id": policy["@id"],
+          hasTarget: !!policy.target
+        } : null,
+        policies: policies.map((p) => ({
+          "@id": p["@id"],
+          hasTarget: !!p.target
+        }))
+      });
       const dest = {
         "@id": serviceId,
         creation_date,
@@ -1585,12 +2490,35 @@ let __tla = (async () => {
         url: service_url,
         provider,
         data_offers,
-        "@type": type
+        "@type": type,
+        ...counterPartyAddress && {
+          counterPartyAddress
+        },
+        ...counterPartyId && {
+          counterPartyId
+        },
+        ...assetId && {
+          assetId
+        },
+        ...datasetId && {
+          datasetId
+        },
+        ...policy && {
+          policy
+        },
+        ...policies.length > 0 && {
+          policies
+        }
       };
+      console.log("[FederatedCatalogueStore] \u{1F50D} Destination object contract fields:", {
+        hasPolicy: "policy" in dest,
+        hasPolicies: "policies" in dest,
+        policiesValue: dest.policies
+      });
       return dest;
     }
   }
-  const _FederatedCatalogueStoreAdapter = class _FederatedCatalogueStoreAdapter {
+  class FederatedCatalogueStoreAdapter {
     constructor() {
     }
     static validateConfiguration(cfg) {
@@ -1606,18 +2534,13 @@ let __tla = (async () => {
       }
     }
     static getStoreInstance(cfg) {
-      if (!_FederatedCatalogueStoreAdapter.store) {
-        if (!cfg) {
-          throw new Error("[FederatedCatalogueStoreAdapter] configuration is required");
-        }
-        _FederatedCatalogueStoreAdapter.validateConfiguration(cfg);
-        _FederatedCatalogueStoreAdapter.store = new FederatedCatalogueStore(cfg);
+      if (!cfg) {
+        throw new Error("[FederatedCatalogueStoreAdapter] configuration is required");
       }
-      return _FederatedCatalogueStoreAdapter.store;
+      FederatedCatalogueStoreAdapter.validateConfiguration(cfg);
+      return new FederatedCatalogueStore(cfg);
     }
-  };
-  __publicField(_FederatedCatalogueStoreAdapter, "store");
-  let FederatedCatalogueStoreAdapter = _FederatedCatalogueStoreAdapter;
+  }
   var lib = {};
   var IdentifierIssuer_1;
   var hasRequiredIdentifierIssuer;
@@ -2934,7 +3857,7 @@ let __tla = (async () => {
   function requireLib() {
     if (hasRequiredLib) return lib;
     hasRequiredLib = 1;
-    (function(exports) {
+    (function(exports$1) {
       const URDNA2015 = requireURDNA2015();
       const URGNA20122 = requireURGNA2012();
       const URDNA2015Sync = requireURDNA2015Sync();
@@ -2946,19 +3869,19 @@ let __tla = (async () => {
       }
       function _inputToDataset(input) {
         if (!Array.isArray(input)) {
-          return exports.NQuads.legacyDatasetToQuads(input);
+          return exports$1.NQuads.legacyDatasetToQuads(input);
         }
         return input;
       }
-      exports.NQuads = requireNQuads$1();
-      exports.IdentifierIssuer = requireIdentifierIssuer();
-      exports._rdfCanonizeNative = function(api) {
+      exports$1.NQuads = requireNQuads$1();
+      exports$1.IdentifierIssuer = requireIdentifierIssuer();
+      exports$1._rdfCanonizeNative = function(api) {
         if (api) {
           rdfCanonizeNative = api;
         }
         return rdfCanonizeNative;
       };
-      exports.canonize = async function(input, options) {
+      exports$1.canonize = async function(input, options) {
         const dataset2 = _inputToDataset(input);
         if (options.useNative) {
           if (!rdfCanonizeNative) {
@@ -2983,7 +3906,7 @@ let __tla = (async () => {
         }
         throw new Error("Invalid RDF Dataset Canonicalization algorithm: " + options.algorithm);
       };
-      exports._canonizeSync = function(input, options) {
+      exports$1._canonizeSync = function(input, options) {
         const dataset2 = _inputToDataset(input);
         if (options.useNative) {
           if (!rdfCanonizeNative) {
@@ -9809,7 +10732,7 @@ let __tla = (async () => {
   function requirePubsub() {
     if (hasRequiredPubsub) return pubsub$1.exports;
     hasRequiredPubsub = 1;
-    (function(module, exports) {
+    (function(module, exports$1) {
       (function(root, factory2) {
         var PubSub2 = {};
         if (root.PubSub) {
@@ -9821,10 +10744,10 @@ let __tla = (async () => {
         }
         {
           if (module !== void 0 && module.exports) {
-            exports = module.exports = PubSub2;
+            exports$1 = module.exports = PubSub2;
           }
-          exports.PubSub = PubSub2;
-          module.exports = exports = PubSub2;
+          exports$1.PubSub = PubSub2;
+          module.exports = exports$1 = PubSub2;
         }
       })(typeof window === "object" && window || pubsub || globalThis, function(PubSub2) {
         var messages = {}, lastUid = -1, ALL_SUBSCRIBING_MSG = "*";
@@ -10597,15 +11520,15 @@ let __tla = (async () => {
   function requireBuffer() {
     if (hasRequiredBuffer) return buffer;
     hasRequiredBuffer = 1;
-    (function(exports) {
+    (function(exports$1) {
       const base64 = requireBase64Js();
       const ieee7542 = requireIeee754();
       const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-      exports.Buffer = Buffer2;
-      exports.SlowBuffer = SlowBuffer;
-      exports.INSPECT_MAX_BYTES = 50;
+      exports$1.Buffer = Buffer2;
+      exports$1.SlowBuffer = SlowBuffer;
+      exports$1.INSPECT_MAX_BYTES = 50;
       const K_MAX_LENGTH = 2147483647;
-      exports.kMaxLength = K_MAX_LENGTH;
+      exports$1.kMaxLength = K_MAX_LENGTH;
       Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
       if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
         console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
@@ -11019,7 +11942,7 @@ let __tla = (async () => {
       };
       Buffer2.prototype.inspect = function inspect2() {
         let str = "";
-        const max = exports.INSPECT_MAX_BYTES;
+        const max = exports$1.INSPECT_MAX_BYTES;
         str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
         if (this.length > max) str += " ... ";
         return "<Buffer " + str + ">";
@@ -12110,7 +13033,7 @@ let __tla = (async () => {
       function numberIsNaN(obj) {
         return obj !== obj;
       }
-      const hexSliceLookupTable = function() {
+      const hexSliceLookupTable = (function() {
         const alphabet = "0123456789abcdef";
         const table = new Array(256);
         for (let i = 0; i < 16; ++i) {
@@ -12120,7 +13043,7 @@ let __tla = (async () => {
           }
         }
         return table;
-      }();
+      })();
       function defineBigIntMethod(fn) {
         return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
       }
@@ -12211,7 +13134,7 @@ let __tla = (async () => {
     function copyBuffer(src, target, offset) {
       Buffer2.prototype.copy.call(src, target, offset);
     }
-    buffer_list$1 = function() {
+    buffer_list$1 = (function() {
       function BufferList() {
         _classCallCheck(this, BufferList);
         this.head = null;
@@ -12379,7 +13302,7 @@ let __tla = (async () => {
         }
       ]);
       return BufferList;
-    }();
+    })();
     return buffer_list$1;
   }
   var destroy_1$1;
@@ -12493,13 +13416,13 @@ let __tla = (async () => {
           return message(arg1, arg2, arg3);
         }
       }
-      var NodeError = function(_Base) {
+      var NodeError = (function(_Base) {
         _inheritsLoose(NodeError2, _Base);
         function NodeError2(arg1, arg2, arg3) {
           return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
         }
         return NodeError2;
-      }(Base);
+      })(Base);
       NodeError.prototype.name = Base.name;
       NodeError.prototype.code = code;
       codes[code] = NodeError;
@@ -13194,7 +14117,7 @@ let __tla = (async () => {
   function requireSafeBuffer() {
     if (hasRequiredSafeBuffer) return safeBuffer.exports;
     hasRequiredSafeBuffer = 1;
-    (function(module, exports) {
+    (function(module, exports$1) {
       var buffer2 = requireBuffer();
       var Buffer2 = buffer2.Buffer;
       function copyProps(src, dst) {
@@ -13205,8 +14128,8 @@ let __tla = (async () => {
       if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
         module.exports = buffer2;
       } else {
-        copyProps(buffer2, exports);
-        exports.Buffer = SafeBuffer;
+        copyProps(buffer2, exports$1);
+        exports$1.Buffer = SafeBuffer;
       }
       function SafeBuffer(arg, encodingOrOffset, length) {
         return Buffer2(arg, encodingOrOffset, length);
@@ -14393,11 +15316,11 @@ let __tla = (async () => {
       });
       for (var i in stream2) {
         if (this[i] === void 0 && typeof stream2[i] === "function") {
-          this[i] = /* @__PURE__ */ function methodWrap(method) {
+          this[i] = /* @__PURE__ */ (function methodWrap(method) {
             return function methodWrapReturnFunction() {
               return stream2[method].apply(stream2, arguments);
             };
-          }(i);
+          })(i);
         }
       }
       for (var n = 0; n < kProxyEvents.length; n++) {
@@ -19163,50 +20086,64 @@ let __tla = (async () => {
         createDebug.namespaces = namespaces2;
         createDebug.names = [];
         createDebug.skips = [];
-        let i;
-        const split = (typeof namespaces2 === "string" ? namespaces2 : "").split(/[\s,]+/);
-        const len = split.length;
-        for (i = 0; i < len; i++) {
-          if (!split[i]) {
-            continue;
+        const split = (typeof namespaces2 === "string" ? namespaces2 : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns2 of split) {
+          if (ns2[0] === "-") {
+            createDebug.skips.push(ns2.slice(1));
+          } else {
+            createDebug.names.push(ns2);
           }
-          namespaces2 = split[i].replace(/\*/g, ".*?");
-          if (namespaces2[0] === "-") {
-            createDebug.skips.push(new RegExp("^" + namespaces2.slice(1) + "$"));
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
           } else {
-            createDebug.names.push(new RegExp("^" + namespaces2 + "$"));
+            return false;
           }
         }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
       }
       function disable() {
         const namespaces2 = [
-          ...createDebug.names.map(toNamespace),
-          ...createDebug.skips.map(toNamespace).map((namespace2) => "-" + namespace2)
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace2) => "-" + namespace2)
         ].join(",");
         createDebug.enable("");
         return namespaces2;
       }
       function enabled(name) {
-        if (name[name.length - 1] === "*") {
-          return true;
-        }
-        let i;
-        let len;
-        for (i = 0, len = createDebug.skips.length; i < len; i++) {
-          if (createDebug.skips[i].test(name)) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
             return false;
           }
         }
-        for (i = 0, len = createDebug.names.length; i < len; i++) {
-          if (createDebug.names[i].test(name)) {
+        for (const ns2 of createDebug.names) {
+          if (matchesTemplate(name, ns2)) {
             return true;
           }
         }
         return false;
       }
-      function toNamespace(regexp) {
-        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
-      }
       function coerce(val) {
         if (val instanceof Error) {
           return val.stack || val.message;
@@ -19226,13 +20163,13 @@ let __tla = (async () => {
   function requireBrowser$3() {
     if (hasRequiredBrowser$3) return browser$3.exports;
     hasRequiredBrowser$3 = 1;
-    (function(module, exports) {
-      exports.formatArgs = formatArgs;
-      exports.save = save;
-      exports.load = load;
-      exports.useColors = useColors;
-      exports.storage = localstorage();
-      exports.destroy = /* @__PURE__ */ (() => {
+    (function(module, exports$1) {
+      exports$1.formatArgs = formatArgs;
+      exports$1.save = save;
+      exports$1.load = load;
+      exports$1.useColors = useColors;
+      exports$1.storage = localstorage();
+      exports$1.destroy = /* @__PURE__ */ (() => {
         let warned = false;
         return () => {
           if (!warned) {
@@ -19241,7 +20178,7 @@ let __tla = (async () => {
           }
         };
       })();
-      exports.colors = [
+      exports$1.colors = [
         "#0000CC",
         "#0000FF",
         "#0033CC",
@@ -19326,7 +20263,8 @@ let __tla = (async () => {
         if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
           return false;
         }
-        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+        let m;
+        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
       }
       function formatArgs(args) {
         args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
@@ -19348,14 +20286,14 @@ let __tla = (async () => {
         });
         args.splice(lastC, 0, c);
       }
-      exports.log = console.debug || console.log || (() => {
+      exports$1.log = console.debug || console.log || (() => {
       });
       function save(namespaces2) {
         try {
           if (namespaces2) {
-            exports.storage.setItem("debug", namespaces2);
+            exports$1.storage.setItem("debug", namespaces2);
           } else {
-            exports.storage.removeItem("debug");
+            exports$1.storage.removeItem("debug");
           }
         } catch (error2) {
         }
@@ -19363,7 +20301,7 @@ let __tla = (async () => {
       function load() {
         let r;
         try {
-          r = exports.storage.getItem("debug");
+          r = exports$1.storage.getItem("debug") || exports$1.storage.getItem("DEBUG");
         } catch (error2) {
         }
         if (!r && typeof process !== "undefined" && "env" in process) {
@@ -19377,7 +20315,7 @@ let __tla = (async () => {
         } catch (error2) {
         }
       }
-      module.exports = requireCommon()(exports);
+      module.exports = requireCommon()(exports$1);
       const { formatters } = module.exports;
       formatters.j = function(v) {
         try {
@@ -20222,8 +21160,8 @@ let __tla = (async () => {
   function requireRdfDataFactory() {
     if (hasRequiredRdfDataFactory) return rdfDataFactory;
     hasRequiredRdfDataFactory = 1;
-    (function(exports) {
-      var __createBinding = rdfDataFactory && rdfDataFactory.__createBinding || (Object.create ? function(o, m, k, k2) {
+    (function(exports$1) {
+      var __createBinding = rdfDataFactory && rdfDataFactory.__createBinding || (Object.create ? (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         var desc = Object.getOwnPropertyDescriptor(m, k);
         if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -20235,23 +21173,23 @@ let __tla = (async () => {
           };
         }
         Object.defineProperty(o, k2, desc);
-      } : function(o, m, k, k2) {
+      }) : (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         o[k2] = m[k];
-      });
-      var __exportStar = rdfDataFactory && rdfDataFactory.__exportStar || function(m, exports2) {
-        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+      }));
+      var __exportStar = rdfDataFactory && rdfDataFactory.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
       };
-      Object.defineProperty(exports, "__esModule", {
+      Object.defineProperty(exports$1, "__esModule", {
         value: true
       });
-      __exportStar(requireBlankNode(), exports);
-      __exportStar(requireDataFactory(), exports);
-      __exportStar(requireDefaultGraph(), exports);
-      __exportStar(requireLiteral(), exports);
-      __exportStar(requireNamedNode(), exports);
-      __exportStar(requireQuad(), exports);
-      __exportStar(requireVariable(), exports);
+      __exportStar(requireBlankNode(), exports$1);
+      __exportStar(requireDataFactory(), exports$1);
+      __exportStar(requireDefaultGraph(), exports$1);
+      __exportStar(requireLiteral(), exports$1);
+      __exportStar(requireNamedNode(), exports$1);
+      __exportStar(requireQuad(), exports$1);
+      __exportStar(requireVariable(), exports$1);
     })(rdfDataFactory);
     return rdfDataFactory;
   }
@@ -20555,8 +21493,8 @@ let __tla = (async () => {
   function requireHandler() {
     if (hasRequiredHandler) return handler;
     hasRequiredHandler = 1;
-    (function(exports) {
-      var __createBinding = handler && handler.__createBinding || (Object.create ? function(o, m, k, k2) {
+    (function(exports$1) {
+      var __createBinding = handler && handler.__createBinding || (Object.create ? (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         var desc = Object.getOwnPropertyDescriptor(m, k);
         if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -20568,21 +21506,21 @@ let __tla = (async () => {
           };
         }
         Object.defineProperty(o, k2, desc);
-      } : function(o, m, k, k2) {
+      }) : (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         o[k2] = m[k];
-      });
-      var __exportStar = handler && handler.__exportStar || function(m, exports2) {
-        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+      }));
+      var __exportStar = handler && handler.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
       };
-      Object.defineProperty(exports, "__esModule", {
+      Object.defineProperty(exports$1, "__esModule", {
         value: true
       });
-      __exportStar(requireTypeHandlerBoolean(), exports);
-      __exportStar(requireTypeHandlerDate(), exports);
-      __exportStar(requireTypeHandlerNumberDouble(), exports);
-      __exportStar(requireTypeHandlerNumberInteger(), exports);
-      __exportStar(requireTypeHandlerString(), exports);
+      __exportStar(requireTypeHandlerBoolean(), exports$1);
+      __exportStar(requireTypeHandlerDate(), exports$1);
+      __exportStar(requireTypeHandlerNumberDouble(), exports$1);
+      __exportStar(requireTypeHandlerNumberInteger(), exports$1);
+      __exportStar(requireTypeHandlerString(), exports$1);
     })(handler);
     return handler;
   }
@@ -20600,8 +21538,8 @@ let __tla = (async () => {
   function requireRdfLiteral() {
     if (hasRequiredRdfLiteral) return rdfLiteral;
     hasRequiredRdfLiteral = 1;
-    (function(exports) {
-      var __createBinding = rdfLiteral && rdfLiteral.__createBinding || (Object.create ? function(o, m, k, k2) {
+    (function(exports$1) {
+      var __createBinding = rdfLiteral && rdfLiteral.__createBinding || (Object.create ? (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         var desc = Object.getOwnPropertyDescriptor(m, k);
         if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -20613,27 +21551,27 @@ let __tla = (async () => {
           };
         }
         Object.defineProperty(o, k2, desc);
-      } : function(o, m, k, k2) {
+      }) : (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         o[k2] = m[k];
-      });
-      var __exportStar = rdfLiteral && rdfLiteral.__exportStar || function(m, exports2) {
-        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+      }));
+      var __exportStar = rdfLiteral && rdfLiteral.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
       };
-      Object.defineProperty(exports, "__esModule", {
+      Object.defineProperty(exports$1, "__esModule", {
         value: true
       });
-      exports.fromRdf = fromRdf2;
-      exports.toRdf = toRdf2;
-      exports.getTermRaw = getTermRaw;
-      exports.getSupportedRdfDatatypes = getSupportedRdfDatatypes;
-      exports.getSupportedJavaScriptPrimitives = getSupportedJavaScriptPrimitives;
+      exports$1.fromRdf = fromRdf2;
+      exports$1.toRdf = toRdf2;
+      exports$1.getTermRaw = getTermRaw;
+      exports$1.getSupportedRdfDatatypes = getSupportedRdfDatatypes;
+      exports$1.getSupportedJavaScriptPrimitives = getSupportedJavaScriptPrimitives;
       const rdf_data_factory_1 = requireRdfDataFactory();
       const handler_1 = requireHandler();
       const Translator_1 = requireTranslator();
-      __exportStar(requireHandler(), exports);
-      __exportStar(requireITypeHandler(), exports);
-      __exportStar(requireTranslator(), exports);
+      __exportStar(requireHandler(), exports$1);
+      __exportStar(requireITypeHandler(), exports$1);
+      __exportStar(requireTranslator(), exports$1);
       const DF = new rdf_data_factory_1.DataFactory();
       const translator = new Translator_1.Translator();
       translator.registerHandler(new handler_1.TypeHandlerString(), handler_1.TypeHandlerString.TYPES.map((t) => DF.namedNode(t)), [
@@ -24971,8 +25909,8 @@ let __tla = (async () => {
       this.pipes = [];
       this.flowing = null;
       this[kPaused] = null;
-      if (options && options.emitClose === false) this.state &= -2049;
-      if (options && options.autoDestroy === false) this.state &= -4097;
+      if (options && options.emitClose === false) this.state &= ~kEmitClose;
+      if (options && options.autoDestroy === false) this.state &= ~kAutoDestroy;
       this.errored = null;
       this.defaultEncoding = options && options.defaultEncoding || "utf8";
       this.awaitDrainWriters = null;
@@ -25053,7 +25991,7 @@ let __tla = (async () => {
       if (err) {
         errorOrDestroy(stream2, err);
       } else if (chunk === null) {
-        state2.state &= -9;
+        state2.state &= ~kReading;
         onEofChunk(stream2, state2);
       } else if ((state2.state & kObjectMode) !== 0 || chunk && chunk.length > 0) {
         if (addToFront) {
@@ -25065,7 +26003,7 @@ let __tla = (async () => {
         } else if (state2.destroyed || state2.errored) {
           return false;
         } else {
-          state2.state &= -9;
+          state2.state &= ~kReading;
           if (state2.decoder && !encoding) {
             chunk = state2.decoder.write(chunk);
             if (state2.objectMode || chunk.length !== 0) addChunk(stream2, state2, chunk, false);
@@ -25075,7 +26013,7 @@ let __tla = (async () => {
           }
         }
       } else if (!addToFront) {
-        state2.state &= -9;
+        state2.state &= ~kReading;
         maybeReadMore(stream2, state2);
       }
       return !state2.ended && (state2.length < state2.highWaterMark || state2.length === 0);
@@ -25150,7 +26088,7 @@ let __tla = (async () => {
       const state2 = this._readableState;
       const nOrig = n;
       if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n);
-      if (n !== 0) state2.state &= -129;
+      if (n !== 0) state2.state &= ~kEmittedReadable;
       if (n === 0 && state2.needReadable && ((state2.highWaterMark !== 0 ? state2.length >= state2.highWaterMark : state2.length > 0) || state2.ended)) {
         debug2("read: emitReadable", state2.length, state2.ended);
         if (state2.length === 0 && state2.ended) endReadable(this);
@@ -25180,7 +26118,7 @@ let __tla = (async () => {
         } catch (err) {
           errorOrDestroy(this, err);
         }
-        state2.state &= -33;
+        state2.state &= ~kSync;
         if (!state2.reading) n = howMuchToRead(nOrig, state2);
       }
       let ret;
@@ -26556,7 +27494,7 @@ let __tla = (async () => {
       let { promise, resolve } = createDeferredPromise();
       const ac = new AbortController();
       const signal = ac.signal;
-      const value = fn(async function* () {
+      const value = fn((async function* () {
         while (true) {
           const _promise = promise;
           promise = null;
@@ -26569,7 +27507,7 @@ let __tla = (async () => {
           ({ promise, resolve } = createDeferredPromise());
           yield chunk;
         }
-      }(), {
+      })(), {
         signal
       });
       return {
@@ -28112,6 +29050,25 @@ let __tla = (async () => {
     constructor(dataFetcher) {
       this.dataFetcher = dataFetcher;
     }
+    getGlobalIndexLoader() {
+      return globalThis.SEMANTIZER_INDEX_LOADER;
+    }
+    getGlobalQuadStreamLoader() {
+      return globalThis.SEMANTIZER_QUAD_STREAM_LOADER;
+    }
+    buildHttpHeaders(dspHeaders) {
+      const headers = {};
+      if (dspHeaders == null ? void 0 : dspHeaders.agreementId) {
+        headers["DSP-AGREEMENT-ID"] = dspHeaders.agreementId;
+      }
+      if (dspHeaders == null ? void 0 : dspHeaders.participantId) {
+        headers["DSP-PARTICIPANT-ID"] = dspHeaders.participantId;
+      }
+      if (dspHeaders == null ? void 0 : dspHeaders.consumerConnectorUrl) {
+        headers["DSP-CONSUMER-CONNECTORURL"] = dspHeaders.consumerConnectorUrl;
+      }
+      return headers;
+    }
     isValidUrl(url2) {
       if (!url2 || typeof url2 !== "string") {
         return false;
@@ -28126,19 +29083,39 @@ let __tla = (async () => {
     hasValidIndexUrl(options) {
       return this.isValidUrl(options.dataSrcIndex ?? "") || this.isValidUrl(options.dataSrcProfile ?? "");
     }
+    hasValidIndexSource(options) {
+      return this.hasValidIndexUrl(options) || options.indexData !== void 0 && options.indexData !== null;
+    }
+    async buildIndexFromJsonLd(jsonLdData) {
+      const jsonString = JSON.stringify(jsonLdData);
+      const base64Data = btoa(unescape(encodeURIComponent(jsonString)));
+      const dataUrl = `data:application/ld+json;base64,${base64Data}`;
+      const index = await SEMANTIZER.load(dataUrl, indexFactory);
+      return index;
+    }
     async query(options) {
-      let indexUri;
-      if (options.dataSrcIndex) {
-        indexUri = options.dataSrcIndex;
-      } else if (options.dataSrcProfile) {
-        indexUri = await this.discoverIndexFromProfile(options.dataSrcProfile);
-      } else {
-        console.warn("Either dataSrcIndex or dataSrcProfile must be specified");
-        return [];
-      }
-      if (!this.isValidUrl(indexUri)) {
-        console.warn("\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndex] Invalid index URI, returning empty results");
-        return [];
+      const dspHttpHeaders = this.buildHttpHeaders(options.dspHeaders);
+      const hasDspHeaders = Object.keys(dspHttpHeaders).length > 0;
+      if (hasDspHeaders) {
+        console.log("[SolidIndexingSearchProvider] Setting DSP headers on global loaders:", dspHttpHeaders);
+        this.getGlobalIndexLoader().setCustomHeaders(dspHttpHeaders);
+        this.getGlobalQuadStreamLoader().setCustomHeaders(dspHttpHeaders);
+      }
+      let indexUri = null;
+      const hasDirectData = options.indexData !== void 0 && options.indexData !== null;
+      if (!hasDirectData) {
+        if (options.dataSrcIndex) {
+          indexUri = options.dataSrcIndex;
+        } else if (options.dataSrcProfile) {
+          indexUri = await this.discoverIndexFromProfile(options.dataSrcProfile);
+        } else {
+          console.warn("Either dataSrcIndex, dataSrcProfile, or indexData must be specified");
+          return [];
+        }
+        if (!this.isValidUrl(indexUri)) {
+          console.warn("\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndex] Invalid index URI, returning empty results");
+          return [];
+        }
       }
       const filterFields = Object.entries(options.filterValues);
       const firstField = filterFields[0];
@@ -28167,10 +29144,28 @@ let __tla = (async () => {
       subIndexShapeGraph.addAll(parser.parse(subIndexShape));
       const shaclValidator = new ValidatorImpl();
       const entryTransformer = new EntryStreamTransformerDefaultImpl(SEMANTIZER);
+      console.log("[SolidIndexingSearchProvider] Generated shapes for query:");
+      console.log("[SolidIndexingSearchProvider] - targetShape:", targetShape);
+      console.log("[SolidIndexingSearchProvider] - subIndexShape:", subIndexShape);
+      console.log("[SolidIndexingSearchProvider] - finalShape:", finalShape);
       const finalIndexStrategy = new IndexStrategyFinalShapeDefaultImpl(finalIndexShapeGraph, subIndexShapeGraph, shaclValidator, entryTransformer);
       const shaclStrategy = new IndexQueryingStrategyShaclUsingFinalIndex(targetShapeGraph, finalIndexStrategy, shaclValidator, entryTransformer);
-      const index = await SEMANTIZER.load(indexUri, indexFactory);
+      let index;
+      if (hasDirectData && options.indexData) {
+        index = await this.buildIndexFromJsonLd(options.indexData);
+      } else if (indexUri) {
+        index = await SEMANTIZER.load(indexUri, indexFactory);
+      } else {
+        console.warn("\u26A0\uFE0F [SolidIndexingSearchProvider.queryIndex] No index source available");
+        return [];
+      }
+      console.log("[SolidIndexingSearchProvider] Starting index query...");
+      console.log("[SolidIndexingSearchProvider] Index loaded, starting query with shaclStrategy");
       const resultStream = index.mixins.index.query(shaclStrategy);
+      resultStream.on("error", (err) => {
+        console.error("[SolidIndexingSearchProvider] Stream error:", err);
+      });
+      const skipResourceFetch = options.skipResourceFetch === true;
       return new Promise((resolve, reject) => {
         const resultIds = [];
         const resources = [];
@@ -28178,15 +29173,24 @@ let __tla = (async () => {
         let streamEnded = false;
         const checkComplete = () => {
           if (streamEnded && pendingFetches === 0) {
-            resolve(resources);
+            if (skipResourceFetch) {
+              resolve(resultIds.map((id) => ({
+                "@id": id
+              })));
+            } else {
+              resolve(resources);
+            }
           }
         };
         resultStream.on("data", async (result) => {
           if (result.value) {
             resultIds.push(result.value);
+            if (skipResourceFetch) {
+              return;
+            }
             pendingFetches++;
             try {
-              const resource = await this.dataFetcher(result.value);
+              const resource = await this.dataFetcher(result.value, hasDspHeaders ? dspHttpHeaders : void 0);
               if (resource) {
                 resources.push(resource);
               } else {
@@ -28206,6 +29210,10 @@ let __tla = (async () => {
         });
         resultStream.on("end", () => {
           streamEnded = true;
+          if (hasDspHeaders) {
+            this.getGlobalIndexLoader().clearCustomHeaders();
+            this.getGlobalQuadStreamLoader().clearCustomHeaders();
+          }
           checkComplete();
         });
       });
@@ -28226,7 +29234,8 @@ let __tla = (async () => {
           filterValues: {
             [propertyName]: filterValue
           },
-          exactMatchMapping: options.exactMatchMapping
+          exactMatchMapping: options.exactMatchMapping,
+          dspHeaders: options.dspHeaders
         };
         return this.query(queryOptions);
       });
@@ -28467,9 +29476,9 @@ sh:property [
       __publicField(this, "loadingList");
       __publicField(this, "headers");
       __publicField(this, "fetch");
-      __publicField(this, "session");
       __publicField(this, "contextParser");
       __publicField(this, "searchProvider");
+      __publicField(this, "cleanupAuth");
       __publicField(this, "resolveResource", (id, resolve) => {
         const handler2 = (event) => {
           if (event.detail.id === id) {
@@ -28483,6 +29492,11 @@ sh:property [
         };
         return handler2;
       });
+      __publicField(this, "resolveFetch", (event) => {
+        if (event.detail.fetch) {
+          this.fetch = event.detail.fetch.bind ? event.detail.fetch.bind(globalThis) : event.detail.fetch;
+        }
+      });
       this.storeOptions = storeOptions;
       this.cache = this.storeOptions.cacheManager ?? new InMemoryCacheManager();
       this.subscriptionIndex = /* @__PURE__ */ new Map();
@@ -28493,15 +29507,38 @@ sh:property [
         "Content-Type": "application/ld+json",
         "Cache-Control": "must-revalidate"
       };
-      this.fetch = this.storeOptions.fetchMethod;
-      this.session = this.storeOptions.session;
       this.contextParser = new jsonldContextParserExports.ContextParser();
-      this.searchProvider = new SolidIndexingSearchProvider(this.getData.bind(this));
+      const headersAwareDataFetcher = (id, customHeaders) => {
+        return this.getData(id, void 0, void 0, void 0, false, void 0, void 0, customHeaders);
+      };
+      this.searchProvider = new SolidIndexingSearchProvider(headersAwareDataFetcher);
+      if (this.storeOptions.fetchMethod) {
+        this.fetch = this.storeOptions.fetchMethod.bind(globalThis);
+      } else {
+        const authFetch = AuthFetchResolver.getAuthFetch();
+        this.fetch = authFetch.bind ? authFetch.bind(globalThis) : authFetch;
+        this.cleanupAuth = AuthFetchResolver.onAuthActivated(this.resolveFetch.bind(this));
+      }
+      if (!this.fetch) {
+        this.fetch = fetch;
+      }
+      const event = new CustomEvent("sib-core:loaded", {
+        bubbles: true,
+        composed: true,
+        detail: {
+          store: this
+        }
+      });
+      window.dispatchEvent(event);
     }
     async initGetter() {
-      const { CustomGetter } = await import("./custom-getter-cITbP3Tj.js");
+      const { CustomGetter } = await import("./custom-getter-BrHW1EBb.js");
       return CustomGetter;
     }
+    disconnectedCallback() {
+      var _a2;
+      (_a2 = this.cleanupAuth) == null ? void 0 : _a2.call(this);
+    }
     async getData(id, context2, parentId, localData, forceFetch, serverPagination, serverSearch, headers, bypassLoadingList) {
       var _a2;
       let key = id;
@@ -28567,17 +29604,7 @@ sh:property [
       if (!this.fetch) {
         console.warn("No fetch method available");
       }
-      let authenticated = false;
-      if (this.session) authenticated = await this.session;
-      if (this.fetch && authenticated) {
-        return this.fetch.then((fn) => {
-          return fn(iri, options);
-        });
-      }
-      if (options.headers) {
-        options.headers = this._convertHeaders(options.headers);
-      }
-      return fetch(iri, options).then((response) => response);
+      return await this.fetch(iri, options);
     }
     async fetchData(id, context2 = null, parentId = "", serverPagination, serverSearch, headers) {
       let iri = this._getAbsoluteIri(id, context2, parentId);
@@ -28820,19 +29847,19 @@ sh:property [
       ]);
     }
     _getAbsoluteIri(id, context2, parentId) {
+      var _a2;
       let iri = normalizeContext(context2, base_context).expandTerm(id);
       if (!iri) return "";
-      if (parentId && !parentId.startsWith("store://local")) {
-        const parentIri = new URL(parentId, document.location.href).href;
-        iri = new URL(iri, parentIri).href;
-      } else {
-        iri = new URL(iri, document.location.href).href;
+      try {
+        const baseHref = ((_a2 = document == null ? void 0 : document.location) == null ? void 0 : _a2.href) || "";
+        const canUseParent = parentId && !parentId.startsWith("store://local");
+        const base = canUseParent ? new URL(parentId, baseHref).href : baseHref;
+        iri = new URL(iri, base).href;
+      } catch (err) {
+        console.log("[LDPStore _getAbsoluteIri()]", err);
       }
       return iri;
     }
-    async getSession() {
-      return await this.session;
-    }
     _getLanguage() {
       return localStorage.getItem("language") || window.navigator.language.slice(0, 2);
     }
@@ -28850,9 +29877,11 @@ sh:property [
     if (window.sibStore) {
       return window.sibStore;
     }
-    const store2 = new LdpStore((_cfg == null ? void 0 : _cfg.options) || {});
-    window.sibStore = store2;
-    return store2;
+    const store = new LdpStore({
+      ..._cfg == null ? void 0 : _cfg.options
+    });
+    window.sibStore = store;
+    return store;
   }
   const _LdpStoreAdapter = class _LdpStoreAdapter {
     constructor() {
@@ -28866,11 +29895,11 @@ sh:property [
   };
   __publicField(_LdpStoreAdapter, "store");
   let LdpStoreAdapter = _LdpStoreAdapter;
-  hasQueryIndex = function(store2) {
-    return "queryIndex" in store2 && typeof store2.queryIndex === "function";
+  hasQueryIndex = function(store) {
+    return "queryIndex" in store && typeof store.queryIndex === "function";
   };
-  hasSetLocalData = function(store2) {
-    return "setLocalData" in store2 && typeof store2.setLocalData === "function";
+  hasSetLocalData = function(store) {
+    return "setLocalData" in store && typeof store.setLocalData === "function";
   };
   StoreType = ((StoreType2) => {
     StoreType2["LDP"] = "ldp";
@@ -28895,37 +29924,106 @@ sh:property [
   StoreFactory.register(StoreType.FederatedCatalogue, FederatedCatalogueStoreAdapter);
   StoreFactory.register(StoreType.DataspaceConnector, DataspaceConnectorStoreAdapter);
   StoreService = (_a = class {
-    static init(config) {
-      if (StoreService.currentStore) {
-        console.warn("[StoreService] Store already initialized. Ignoring duplicate init.");
-        return;
+    static addStore(name, config) {
+      var _a2;
+      const trimmedName = name.trim();
+      if (!trimmedName) {
+        throw new Error("[StoreService] Store name cannot be empty.");
+      }
+      if (!config) {
+        throw new Error("[StoreService] Store configuration is required.");
+      }
+      console.log(`\u{1F527} [StoreService.addStore] Adding store "${trimmedName}":`, {
+        storeType: config.type,
+        endpoint: config.endpoint,
+        alreadyExists: StoreService.stores.has(trimmedName)
+      });
+      if (StoreService.stores.has(trimmedName)) {
+        StoreService.logWarning(`Store with name "${trimmedName}" already exists. Overwriting.`);
+      }
+      const store = StoreFactory.create(config);
+      console.log(`\u2705 [StoreService.addStore] Created store for "${trimmedName}":`, {
+        storeType: typeof store,
+        storeConfig: store.config,
+        storeEndpoint: (_a2 = store.config) == null ? void 0 : _a2.endpoint
+      });
+      StoreService.stores.set(trimmedName, {
+        store,
+        config
+      });
+      return store;
+    }
+    static getStore(name) {
+      var _a2;
+      const storeName = StoreService.resolveStoreName(name);
+      if (!storeName) {
+        return null;
+      }
+      const instance = StoreService.stores.get(storeName);
+      if (!instance) {
+        if (storeName === StoreService.defaultStoreName) {
+          return StoreService.fallbackInitIfNeeded();
+        }
+        StoreService.logWarning(`Store with name "${storeName}" not found.`);
+        return null;
       }
-      StoreService.currentConfig = config ?? {
+      console.log(`\u{1F4E6} [StoreService.getStore] Retrieving store "${storeName}":`, {
+        found: !!instance,
+        storeEndpoint: (_a2 = instance.store.config) == null ? void 0 : _a2.endpoint,
+        configEndpoint: instance.config.endpoint
+      });
+      return instance.store;
+    }
+    static setDefaultStore(name) {
+      if (!(name == null ? void 0 : name.trim())) {
+        throw new Error("[StoreService] Store name cannot be empty.");
+      }
+      if (!StoreService.stores.has(name)) {
+        throw new Error(`[StoreService] Store with name "${name}" not found.`);
+      }
+      StoreService.defaultStoreName = name;
+    }
+    static init(config) {
+      const storeConfig = config ?? {
         type: StoreType.LDP
       };
-      const store2 = StoreFactory.create(StoreService.currentConfig);
-      StoreService.currentStore = store2;
+      StoreService.addStore(StoreService.defaultStoreName, storeConfig);
+      StoreService.setDefaultStore(StoreService.defaultStoreName);
     }
     static fallbackInitIfNeeded() {
-      if (!StoreService.currentStore) {
+      let instance = StoreService.stores.get(StoreService.defaultStoreName);
+      if (!instance) {
         const defaultConfig = {
           type: StoreType.LDP
         };
-        const store2 = StoreFactory.create(defaultConfig);
-        StoreService.currentStore = store2;
-        StoreService.currentConfig = defaultConfig;
+        const store = StoreFactory.create(defaultConfig);
+        instance = {
+          store,
+          config: defaultConfig
+        };
+        StoreService.stores.set(StoreService.defaultStoreName, instance);
       }
-      return StoreService.currentStore;
+      return instance.store;
     }
     static getInstance() {
-      if (StoreService.currentStore) return StoreService.currentStore;
-      const store2 = StoreService.fallbackInitIfNeeded();
-      return store2;
+      const store = StoreService.getStore(StoreService.defaultStoreName);
+      if (!store) {
+        throw new Error("[StoreService] Failed to get or create default store instance.");
+      }
+      return store;
     }
-    static getConfig() {
-      return StoreService.currentConfig;
+    static getConfig(name) {
+      const storeName = StoreService.resolveStoreName(name);
+      const instance = StoreService.stores.get(storeName);
+      return (instance == null ? void 0 : instance.config) || null;
     }
-  }, __publicField(_a, "currentStore", null), __publicField(_a, "currentConfig", null), _a);
+    static resolveStoreName(name) {
+      return (name == null ? void 0 : name.trim()) || StoreService.defaultStoreName;
+    }
+    static logWarning(message) {
+      console.warn(`[StoreService] ${message}`);
+    }
+  }, __publicField(_a, "stores", /* @__PURE__ */ new Map()), __publicField(_a, "defaultStoreName", "default"), _a);
   var __awaiter$3 = function(thisArg, _arguments, P, generator) {
     function adopt(value) {
       return value instanceof P ? value : new P(function(resolve) {
@@ -29156,8 +30254,8 @@ sh:property [
     setLoader(loader) {
       this._loader = loader;
     }
-    setLoaderQuadStream(loaderQuadStream) {
-      this._loaderQuadStream = loaderQuadStream;
+    setLoaderQuadStream(loaderQuadStream2) {
+      this._loaderQuadStream = loaderQuadStream2;
     }
     setRdfDataModelFactory(dataFactory) {
       this._rdfModelDataFactory = dataFactory;
@@ -32742,8 +33840,8 @@ sh:property [
   function requireJsonldStreamingParser() {
     if (hasRequiredJsonldStreamingParser) return jsonldStreamingParser;
     hasRequiredJsonldStreamingParser = 1;
-    (function(exports) {
-      var __createBinding = jsonldStreamingParser && jsonldStreamingParser.__createBinding || (Object.create ? function(o, m, k, k2) {
+    (function(exports$1) {
+      var __createBinding = jsonldStreamingParser && jsonldStreamingParser.__createBinding || (Object.create ? (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         var desc = Object.getOwnPropertyDescriptor(m, k);
         if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
@@ -32755,17 +33853,17 @@ sh:property [
           };
         }
         Object.defineProperty(o, k2, desc);
-      } : function(o, m, k, k2) {
+      }) : (function(o, m, k, k2) {
         if (k2 === void 0) k2 = k;
         o[k2] = m[k];
-      });
-      var __exportStar = jsonldStreamingParser && jsonldStreamingParser.__exportStar || function(m, exports2) {
-        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+      }));
+      var __exportStar = jsonldStreamingParser && jsonldStreamingParser.__exportStar || function(m, exports$12) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$12, p)) __createBinding(exports$12, m, p);
       };
-      Object.defineProperty(exports, "__esModule", {
+      Object.defineProperty(exports$1, "__esModule", {
         value: true
       });
-      __exportStar(requireJsonLdParser(), exports);
+      __exportStar(requireJsonLdParser(), exports$1);
     })(jsonldStreamingParser);
     return jsonldStreamingParser;
   }
@@ -32853,17 +33951,35 @@ sh:property [
       this.getSemantizer().logError(this, message, options);
     }
   }
-  const store$1 = StoreService.getInstance();
   class LoaderQuadStreamCore extends LoaderBase {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "customHeaders", {});
+    }
     getLoggingComponent() {
       return {
         type: "PACKAGE",
         name: "loader-quad-stream-core"
       };
     }
+    setCustomHeaders(headers) {
+      console.log("[LoaderQuadStreamCore] setCustomHeaders called:", headers);
+      this.customHeaders = headers;
+    }
+    clearCustomHeaders() {
+      console.log("[LoaderQuadStreamCore] clearCustomHeaders called");
+      this.customHeaders = {};
+    }
     async load(uri, _otherFetch) {
-      const headers = store$1.headers;
-      const response = await store$1.fetchAuthn(uri, {
+      const store = StoreService.getInstance();
+      const headers = {
+        ...store.headers,
+        ...this.customHeaders
+      };
+      console.log("[LoaderQuadStreamCore] Loading URI:", uri);
+      console.log("[LoaderQuadStreamCore] Custom headers:", this.customHeaders);
+      console.log("[LoaderQuadStreamCore] Final headers:", headers);
+      const response = await store.fetchAuthn(uri, {
         method: "GET",
         headers,
         credentials: "include"
@@ -32883,16 +33999,34 @@ sh:property [
       return quads;
     }
   }
-  const store = StoreService.getInstance();
   class IndexLoader extends LoaderBase {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "customHeaders", {});
+    }
     getLoggingComponent() {
       return {
         type: "PACKAGE",
         name: "loader-quad-stream-core"
       };
     }
+    setCustomHeaders(headers) {
+      console.log("[IndexLoader] setCustomHeaders called:", headers);
+      this.customHeaders = headers;
+    }
+    clearCustomHeaders() {
+      console.log("[IndexLoader] clearCustomHeaders called");
+      this.customHeaders = {};
+    }
     async load(uri) {
-      const headers = store.headers;
+      const store = StoreService.getInstance();
+      const headers = {
+        ...store.headers,
+        ...this.customHeaders
+      };
+      console.log("[IndexLoader] Loading URI:", uri);
+      console.log("[IndexLoader] Custom headers:", this.customHeaders);
+      console.log("[IndexLoader] Final headers:", headers);
       const response = await store.fetchAuthn(uri, {
         method: "GET",
         headers,
@@ -32929,19 +34063,37 @@ sh:property [
       return quadsRes;
     }
   }
+  const indexLoader = new IndexLoader();
+  const loaderQuadStream = new LoaderQuadStreamCore();
   const semantizer$1 = new SemantizerImpl(new ConfigurationImpl({
-    loader: new IndexLoader(),
-    loaderQuadStream: new LoaderQuadStreamCore(),
+    loader: indexLoader,
+    loaderQuadStream,
     datasetImpl: DatasetMixin(DatasetCoreRdfjsImpl),
     rdfModelDataFactory: factory$3,
     mixinFactoryImpl: MixinFactoryImpl,
     datasetBaseFactoryImpl: DatasetBaseFactoryImpl
   }));
-  Object.defineProperty(globalThis, "SEMANTIZER", {
-    value: semantizer$1,
-    writable: false,
-    configurable: false
-  });
+  if (!globalThis.SEMANTIZER) {
+    Object.defineProperty(globalThis, "SEMANTIZER", {
+      value: semantizer$1,
+      writable: false,
+      configurable: true
+    });
+  }
+  if (!globalThis.SEMANTIZER_INDEX_LOADER) {
+    Object.defineProperty(globalThis, "SEMANTIZER_INDEX_LOADER", {
+      value: indexLoader,
+      writable: false,
+      configurable: true
+    });
+  }
+  if (!globalThis.SEMANTIZER_QUAD_STREAM_LOADER) {
+    Object.defineProperty(globalThis, "SEMANTIZER_QUAD_STREAM_LOADER", {
+      value: loaderQuadStream,
+      writable: false,
+      configurable: true
+    });
+  }
   if (typeof window !== "undefined") {
     if (typeof window.process === "undefined") {
       window.process = {
@@ -32969,6 +34121,8 @@ sh:property [
   semantizer = globalThis.SEMANTIZER;
 })();
 export {
+  AuthFetchResolver as A,
+  DEFAULT_AUTH_SELECTORS as D,
   StoreService as S,
   __tla,
   formatAttributesToServerSearchOptions as a,