@startinblox/core 2.0.6-beta.6 → 2.0.6-beta.8

package/dist/{store-B7CtE5CD.js → store-D6BkvCFg.js}

@@ -2,7 +2,7 @@ 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;
+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) {
@@ -278,12 +278,13 @@ let __tla = (async () => {
         protocol: "dataspace-protocol-http",
         policy: {
           "@context": "http://www.w3.org/ns/odrl.jsonld",
-          "@id": policy["@id"],
-          "@type": "Offer",
-          assigner: counterPartyId || "provider",
+          ...policy,
+          "@type": policy["@type"] || "Offer",
+          assigner: policy.assigner || counterPartyId || "provider",
           target: policy.target
         }
       };
+      console.log("[DataspaceConnectorStore] Contract negotiation request:", JSON.stringify(negotiationRequest, null, 2));
       const response = await this.fetchAuthn(this.config.contractNegotiationEndpoint, {
         method: "POST",
         headers: this.headers,
@@ -589,6 +590,86 @@ let __tla = (async () => {
       }
       return await this.fetchWithEDRToken(edrDataAddress, additionalPath);
     }
+    async fetchProtectedResource(resourceUrl, consumerParticipantId, 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, providerConnectorUrl, existingAgreementId);
+      }
+      const initialResponse = await fetch(resourceUrl, {
+        method: "GET",
+        headers: {
+          "DSP-PARTICIPANT-ID": consumerParticipantId,
+          "DSP-CONSUMER-CONNECTORURL": providerConnectorUrl,
+          Accept: "application/json"
+        },
+        mode: "cors"
+      });
+      if (initialResponse.ok) {
+        const data = await initialResponse.json();
+        console.log("\u2705 Resource accessed successfully (no agreement required)");
+        return data;
+      }
+      if (initialResponse.status !== 449) {
+        const errorText = await initialResponse.text();
+        throw new Error(`Unexpected response: ${initialResponse.status} ${initialResponse.statusText} - ${errorText}`);
+      }
+      const agreementId = await this._handlePolicyDiscovery(initialResponse, providerConnectorUrl, maxNegotiationRetries, negotiationRetryDelay);
+      console.log("\u{1F504} Retrying resource request with agreement...");
+      return await this._fetchWithAgreement(resourceUrl, consumerParticipantId, providerConnectorUrl, agreementId);
+    }
+    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})`);
+      console.log("\u{1F91D} Initiating contract negotiation...");
+      const negotiationId = await this.negotiateContract(providerConnectorUrl, errorResponse.asset_id, bestPolicy.policy, errorResponse.participant_id);
+      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);
+          if (!agreement) {
+            throw new Error(`Failed to retrieve contract agreement for negotiation ${negotiationId}`);
+          }
+          console.log(`\u2705 Agreement obtained: ${agreement["@id"]}`);
+          return agreement["@id"];
+        }
+        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/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();
@@ -1273,67 +1354,279 @@ let __tla = (async () => {
   };
   __publicField(_DataspaceConnectorStoreAdapter, "store");
   let DataspaceConnectorStoreAdapter = _DataspaceConnectorStoreAdapter;
-  class FederatedCatalogueAPIWrapper {
-    constructor(options, fcBaseUrl) {
-      __publicField(this, "fcBaseUrl");
-      __publicField(this, "connect");
-      this.fcBaseUrl = fcBaseUrl;
+  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 connection = this.firstConnect(options);
-        this.connect = () => connection;
-      } catch (e) {
-        console.log("Error while establishing the first connection", e);
-        this.connect = null;
+        const authFetch = authElement.getFetch();
+        if (typeof authFetch === "function") {
+          return authFetch;
+        }
+      } catch (error2) {
+        console.warn("[AuthFetchResolver] Error getting auth fetch:", error2);
       }
     }
-    async firstConnect(options) {
-      const body = new URLSearchParams({
-        grant_type: options.kc_grant_type,
-        client_id: options.kc_client_id,
-        client_secret: options.kc_client_secret,
-        scope: options.kc_scope,
-        username: options.kc_username,
-        password: options.kc_password
-      });
-      const headers = new Headers({
-        "Content-Type": "application/x-www-form-urlencoded"
+    return fetch;
+  }
+  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);
+        }
       });
-      const response = await fetch(options.kc_url, {
-        method: "POST",
-        headers,
-        body
+      observer.observe(document.body, {
+        childList: true,
+        subtree: true
       });
-      const data = await response.json();
-      const token = data.access_token;
-      if (token == null) {
-        throw new Error("connexion fails", {
-          cause: data
+      setTimeout(() => {
+        observer.disconnect();
+        reject(new Error(`No auth element found with selectors: ${selectors.join(", ")}`));
+      }, timeout);
+    });
+  }
+  AuthFetchResolver = {
+    findAuthElement,
+    getAuthFetch,
+    onAuthActivated,
+    waitForAuthElement
+  };
+  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
         });
       }
-      return token;
+      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(fcBaseUrl, fetchAuth) {
+      __publicField(this, "fcBaseUrl");
+      __publicField(this, "fetch");
+      this.fcBaseUrl = fcBaseUrl;
+      const baseFetch = fetchAuth || fetch;
+      this.fetch = baseFetch.bind(globalThis);
     }
     async getAllSelfDescriptions() {
-      if (!this.connect) return null;
-      const token = await this.connect();
       const url2 = `${this.fcBaseUrl}/self-descriptions`;
-      const headers = new Headers({
-        Authorization: `Bearer ${token}`
-      });
-      const response = await fetch(url2, {
-        headers
-      });
+      const response = await this.fetch(url2);
       return await response.json();
     }
     async getSelfDescriptionByHash(sdHash) {
-      if (!this.connect) return null;
-      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.fetch(url2, {
+        method: "GET"
       });
       if (!response.ok) throw new Error(`GET /self-descriptions/${sdHash} failed: ${response.status} ${response.statusText}`, {
         cause: response
@@ -1341,18 +1634,15 @@ let __tla = (async () => {
       return await response.json();
     }
     async postQuery(statement, parameters = {}) {
-      if (!this.connect) return null;
-      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.fetch(url2, {
         method: "POST",
         headers,
         body
@@ -1365,11 +1655,8 @@ let __tla = (async () => {
       return await response.json();
     }
     async postQuerySearch(statement, parameters = {}, queryLanguage = "OPENCYPHER", annotations) {
-      if (!this.connect) return null;
-      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({
@@ -1379,7 +1666,7 @@ let __tla = (async () => {
           queryLanguage
         }
       });
-      const response = await fetch(url2, {
+      const response = await this.fetch(url2, {
         method: "POST",
         headers,
         body
@@ -1392,28 +1679,65 @@ let __tla = (async () => {
       return await response.json();
     }
   }
-  function getFederatedCatalogueAPIWrapper(baseUrl, loginOptions) {
-    return new FederatedCatalogueAPIWrapper(loginOptions, baseUrl);
+  function getFederatedCatalogueAPIWrapper(baseUrl, fetch2) {
+    return new FederatedCatalogueAPIWrapper(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, "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");
       }
-      try {
-        this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, this.cfg.login);
-      } catch (e) {
-        console.error("[FederatedCatalogueStore] Failed to initialize API wrapper:", e);
+      const fetchAuth = AuthFetchResolver.getAuthFetch();
+      this.cleanupAuth = AuthFetchResolver.onAuthActivated(this.resolveFetch.bind(this));
+      if (fetchAuth) {
+        this.fcApi = getFederatedCatalogueAPIWrapper(this.cfg.endpoint, fetchAuth);
+      } else {
         this.fcApi = null;
       }
       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;
@@ -1422,28 +1746,184 @@ let __tla = (async () => {
       }
       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) {
+      var _a2;
       const targetType = this.resolveTargetType(args);
       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();
-        if (dataset2) for (const item in dataset2.items) {
-          const sd = await this.fcApi.getSelfDescriptionByHash(dataset2.items[item].meta.sdHash);
+      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);
+    }
+    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");
+      }
+      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: {
@@ -1456,11 +1936,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",
@@ -1521,8 +1998,8 @@ let __tla = (async () => {
     }
     subscribeResourceTo(_resourceId, _nestedResourceId) {
     }
-    fetchAuthn(_iri, _options) {
-      return Promise.resolve({});
+    async fetchAuthn(_iri, _options) {
+      return await Promise.resolve({});
     }
     async setLocalData(resource, id) {
       try {
@@ -1548,8 +2025,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;
@@ -1560,9 +2068,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']");
       }
@@ -1571,7 +2086,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(", ")}` : "";
@@ -1611,19 +2126,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",
@@ -1633,6 +2153,23 @@ 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;
+      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"]) {
+          policy = this.stripTemsUrnFromPolicy(JSON.parse(JSON.stringify(dataset2["odrl:hasPolicy"])));
+          if (datasetId) {
+            policy.target = datasetId;
+          }
+        }
+      }
       const dest = {
         "@id": serviceId,
         creation_date,
@@ -1656,7 +2193,22 @@ let __tla = (async () => {
         url: service_url,
         provider,
         data_offers,
-        "@type": type
+        "@type": type,
+        ...counterPartyAddress && {
+          counterPartyAddress
+        },
+        ...counterPartyId && {
+          counterPartyId
+        },
+        ...assetId && {
+          assetId
+        },
+        ...datasetId && {
+          datasetId
+        },
+        ...policy && {
+          policy
+        }
       };
       return dest;
     }
@@ -28538,9 +29090,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) {
@@ -28554,6 +29106,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();
@@ -28564,15 +29121,35 @@ 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));
+      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-D-s4T-Sk.js");
+      const { CustomGetter } = await import("./custom-getter-WZPa-O0k.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;
@@ -28638,17 +29215,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);
@@ -28891,19 +29458,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);
     }
@@ -28921,16 +29488,8 @@ sh:property [
     if (window.sibStore) {
       return window.sibStore;
     }
-    const storeOptions = {};
-    const sibAuth = document.querySelector("sib-auth");
-    if (sibAuth) {
-      const sibAuthDefined = customElements.whenDefined(sibAuth.localName);
-      storeOptions.session = sibAuthDefined.then(() => sibAuth.session);
-      storeOptions.fetchMethod = sibAuthDefined.then(() => sibAuth.getFetch());
-    }
     const store2 = new LdpStore({
-      ..._cfg == null ? void 0 : _cfg.options,
-      ...storeOptions
+      ..._cfg == null ? void 0 : _cfg.options
     });
     window.sibStore = store2;
     return store2;
@@ -33104,6 +33663,8 @@ sh:property [
   semantizer = globalThis.SEMANTIZER;
 })();
 export {
+  AuthFetchResolver as A,
+  DEFAULT_AUTH_SELECTORS as D,
   StoreService as S,
   __tla,
   formatAttributesToServerSearchOptions as a,