@a-cube-io/ereceipts-js-sdk 2.0.2 → 2.0.4

package/dist/index.native.js

@@ -2459,7 +2459,7 @@ function formatDecimal(value, decimals = 2) {
     return num.toFixed(decimals);
 }
 
-const log$c = createPrefixedLogger('MTLS-HANDLER');
+const log$f = createPrefixedLogger('MTLS-HANDLER');
 class MtlsAuthHandler {
     constructor(mtlsAdapter, certificatePort) {
         this.mtlsAdapter = mtlsAdapter;
@@ -2501,7 +2501,7 @@ class MtlsAuthHandler {
     async makeRequest(url, config, jwtToken) {
         const requestKey = this.generateRequestKey(url, config, jwtToken);
         if (this.pendingRequests.has(requestKey)) {
-            log$c.debug('Deduplicating concurrent request:', url);
+            log$f.debug('Deduplicating concurrent request:', url);
             return this.pendingRequests.get(requestKey);
         }
         const requestPromise = this.executeRequest(url, config, jwtToken, false);
@@ -2525,10 +2525,10 @@ class MtlsAuthHandler {
         };
         if (jwtToken) {
             headers['Authorization'] = `Bearer ${jwtToken}`;
-            log$c.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
+            log$f.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
         }
         else {
-            log$c.warn('No JWT token provided for mTLS request');
+            log$f.warn('No JWT token provided for mTLS request');
         }
         const fullUrl = this.constructMtlsUrl(url);
         const mtlsConfig = {
@@ -2539,25 +2539,25 @@ class MtlsAuthHandler {
             timeout: config.timeout,
             responseType: config.responseType,
         };
-        log$c.debug('header-mtls', headers);
-        log$c.debug(`${config.method} ${fullUrl}`);
+        log$f.debug('header-mtls', headers);
+        log$f.debug(`${config.method} ${fullUrl}`);
         if (config.data) {
-            log$c.debug('Request body:', config.data);
+            log$f.debug('Request body:', config.data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$c.debug(`Response ${response.status} from ${fullUrl}`);
+            log$f.debug(`Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$c.debug('Response body:', response.data);
+                log$f.debug('Response body:', response.data);
             }
             return response.data;
         }
         catch (error) {
-            log$c.error(`Response error from ${fullUrl}:`, error);
+            log$f.error(`Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$c.error('Response body:', axiosError.response.data);
+                    log$f.error('Response body:', axiosError.response.data);
                 }
             }
             if (isRetryAttempt) {
@@ -2567,7 +2567,7 @@ class MtlsAuthHandler {
             if (!shouldRetry) {
                 throw error;
             }
-            log$c.debug('Request failed, reconfiguring certificate and retrying...');
+            log$f.debug('Request failed, reconfiguring certificate and retrying...');
             try {
                 await this.configureCertificate(certificate);
                 return await this.executeRequest(url, config, jwtToken, true);
@@ -3294,7 +3294,7 @@ function decompressData(data, compressed) {
     return new CompressionAdapter().decompress(data, compressed);
 }
 
-const log$b = createPrefixedLogger('CACHE-RN');
+const log$e = createPrefixedLogger('CACHE-RN');
 /**
  * React Native cache adapter using SQLite (Expo or react-native-sqlite-storage)
  * Cache never expires - data persists until explicitly invalidated
@@ -3378,26 +3378,26 @@ class ReactNativeCacheAdapter {
         await this.runMigrations();
     }
     async runMigrations() {
-        log$b.debug('Running database migrations...');
+        log$e.debug('Running database migrations...');
         try {
             // Check if compressed column exists
             this.hasCompressedColumn = await this.checkColumnExists('compressed');
             if (!this.hasCompressedColumn) {
-                log$b.debug('Adding compressed column to cache table');
+                log$e.debug('Adding compressed column to cache table');
                 const addColumnSQL = `ALTER TABLE ${ReactNativeCacheAdapter.TABLE_NAME} ADD COLUMN compressed INTEGER DEFAULT 0`;
                 await this.executeSql(addColumnSQL);
                 this.hasCompressedColumn = true;
-                log$b.debug('Successfully added compressed column');
+                log$e.debug('Successfully added compressed column');
             }
             else {
-                log$b.debug('Compressed column already exists');
+                log$e.debug('Compressed column already exists');
             }
-            log$b.debug('Database migrations completed', {
+            log$e.debug('Database migrations completed', {
                 hasCompressedColumn: this.hasCompressedColumn,
             });
         }
         catch (error) {
-            log$b.debug('Migration failed, disabling compression features', error);
+            log$e.debug('Migration failed, disabling compression features', error);
             this.hasCompressedColumn = false;
             // Don't throw - allow the app to continue even if migration fails
             // The compressed feature will just be disabled
@@ -3408,20 +3408,20 @@ class ReactNativeCacheAdapter {
             const pragmaSQL = `PRAGMA table_info(${ReactNativeCacheAdapter.TABLE_NAME})`;
             const results = await this.executeSql(pragmaSQL);
             const columns = this.normalizeResults(results);
-            log$b.debug('Table columns found', { columns: columns.map((c) => c.name) });
+            log$e.debug('Table columns found', { columns: columns.map((c) => c.name) });
             return columns.some((column) => column.name === columnName);
         }
         catch (error) {
-            log$b.debug('Error checking column existence', error);
+            log$e.debug('Error checking column existence', error);
             return false;
         }
     }
     async get(key) {
         await this.ensureInitialized();
         const sql = `SELECT * FROM ${ReactNativeCacheAdapter.TABLE_NAME} WHERE cache_key = ?`;
-        log$b.debug('Executing get query', { sql, key });
+        log$e.debug('Executing get query', { sql, key });
         const results = await this.executeSql(sql, [key]);
-        log$b.debug('Get query results', { key, hasResults: !!results });
+        log$e.debug('Get query results', { key, hasResults: !!results });
         // Normalize results from different SQLite implementations
         const rows = this.normalizeResults(results);
         if (!rows || rows.length === 0) {
@@ -3444,7 +3444,7 @@ class ReactNativeCacheAdapter {
             data,
             timestamp: Date.now(),
         };
-        log$b.debug('Setting cache item', { key });
+        log$e.debug('Setting cache item', { key });
         return this.setItem(key, item);
     }
     async setItem(key, item) {
@@ -3457,7 +3457,7 @@ class ReactNativeCacheAdapter {
             const compressionResult = compressData(serializedData, this.options.compressionThreshold);
             finalData = compressionResult.data;
             isCompressed = compressionResult.compressed;
-            log$b.debug('Compression result', {
+            log$e.debug('Compression result', {
                 key,
                 originalSize: compressionResult.originalSize,
                 compressedSize: compressionResult.compressedSize,
@@ -3465,7 +3465,7 @@ class ReactNativeCacheAdapter {
                 savings: compressionResult.originalSize - compressionResult.compressedSize,
             });
         }
-        log$b.debug('Setting item with metadata', {
+        log$e.debug('Setting item with metadata', {
             key,
             timestamp: item.timestamp,
             compressed: isCompressed,
@@ -3491,14 +3491,14 @@ class ReactNativeCacheAdapter {
       `;
             params = [key, finalData, item.timestamp];
         }
-        log$b.debug('Executing setItem SQL', { key, paramsCount: params.length });
+        log$e.debug('Executing setItem SQL', { key, paramsCount: params.length });
         await this.executeSql(sql, params);
     }
     async setBatch(items) {
         if (items.length === 0)
             return;
         await this.ensureInitialized();
-        log$b.debug('Batch setting items', { count: items.length });
+        log$e.debug('Batch setting items', { count: items.length });
         if (this.isExpo) {
             await this.db.withTransactionAsync(async () => {
                 for (const [key, item] of items) {
@@ -3516,7 +3516,7 @@ class ReactNativeCacheAdapter {
                 }, reject, () => resolve());
             });
         }
-        log$b.debug('Batch operation completed', { count: items.length });
+        log$e.debug('Batch operation completed', { count: items.length });
     }
     async setBatchItem(key, item) {
         // Handle compression if enabled and compressed column is available
@@ -3690,10 +3690,10 @@ class MemoryCacheAdapter {
         return keySize + itemSize;
     }
     async get(key) {
-        log$b.debug('Getting cache item', { key });
+        log$e.debug('Getting cache item', { key });
         const item = this.cache.get(key);
         if (!item) {
-            log$b.debug('Cache miss', { key });
+            log$e.debug('Cache miss', { key });
             return null;
         }
         // Handle decompression if needed
@@ -3703,7 +3703,7 @@ class MemoryCacheAdapter {
             const decompressed = decompressData(item.data, true);
             finalData = JSON.parse(decompressed.data);
         }
-        log$b.debug('Cache hit', { key, compressed: isCompressed });
+        log$e.debug('Cache hit', { key, compressed: isCompressed });
         return {
             ...item,
             data: finalData,
@@ -3711,7 +3711,7 @@ class MemoryCacheAdapter {
         };
     }
     async set(key, data) {
-        log$b.debug('Setting cache item', { key });
+        log$e.debug('Setting cache item', { key });
         // Handle compression if enabled
         let finalData = data;
         let isCompressed = false;
@@ -3721,7 +3721,7 @@ class MemoryCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$b.debug('Compression result', {
+                log$e.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -3753,13 +3753,13 @@ class MemoryCacheAdapter {
                 const oldestItemSize = this.calculateItemSize(oldestKey, oldestItem);
                 this.totalBytes -= oldestItemSize;
                 this.cache.delete(oldestKey);
-                log$b.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
+                log$e.debug('Removed oldest item for capacity', { oldestKey, freedBytes: oldestItemSize });
             }
         }
         // Set new item and update total size
         this.cache.set(key, item);
         this.totalBytes += newItemSize;
-        log$b.debug('Updated cache size', {
+        log$e.debug('Updated cache size', {
             entries: this.cache.size,
             totalBytes: this.totalBytes,
             newItemSize,
@@ -3768,7 +3768,7 @@ class MemoryCacheAdapter {
     async setBatch(items) {
         if (items.length === 0)
             return;
-        log$b.debug('Batch setting items', { count: items.length });
+        log$e.debug('Batch setting items', { count: items.length });
         let totalNewBytes = 0;
         let totalOldBytes = 0;
         const itemsToRemove = [];
@@ -3797,7 +3797,7 @@ class MemoryCacheAdapter {
                 itemsToRemove.push(oldKey);
             }
             if (itemsToRemove.length > 0) {
-                log$b.debug('Removed items for batch capacity', {
+                log$e.debug('Removed items for batch capacity', {
                     removedCount: itemsToRemove.length,
                     removedKeys: itemsToRemove,
                 });
@@ -3809,7 +3809,7 @@ class MemoryCacheAdapter {
         for (const [key, item] of items) {
             this.cache.set(key, item);
         }
-        log$b.debug('Batch operation completed', {
+        log$e.debug('Batch operation completed', {
             count: items.length,
             totalBytes: this.totalBytes,
             entries: this.cache.size,
@@ -3831,7 +3831,7 @@ class MemoryCacheAdapter {
             }
         }
         if (removed > 0) {
-            log$b.debug('Invalidation completed', {
+            log$e.debug('Invalidation completed', {
                 pattern,
                 entriesRemoved: removed,
                 bytesFreed,
@@ -3843,7 +3843,7 @@ class MemoryCacheAdapter {
     async clear() {
         this.cache.clear();
         this.totalBytes = 0;
-        log$b.debug('Cache cleared', { entries: 0, bytes: 0 });
+        log$e.debug('Cache cleared', { entries: 0, bytes: 0 });
     }
     async getSize() {
         return {
@@ -4174,7 +4174,7 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-const log$a = createPrefixedLogger('CACHE-WEB');
+const log$d = createPrefixedLogger('CACHE-WEB');
 /**
  * Web cache adapter using IndexedDB with automatic error recovery
  * Cache never expires - data persists until explicitly invalidated
@@ -4197,18 +4197,18 @@ class WebCacheAdapter {
     async initialize() {
         if (this.db)
             return;
-        log$a.debug('Initializing IndexedDB cache', {
+        log$d.debug('Initializing IndexedDB cache', {
             dbName: WebCacheAdapter.DB_NAME,
             version: WebCacheAdapter.DB_VERSION,
         });
         try {
             this.db = await this.openDatabase();
-            log$a.debug('IndexedDB cache initialized successfully');
+            log$d.debug('IndexedDB cache initialized successfully');
             this.retryCount = 0; // Reset retry count on success
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            log$a.debug('Failed to initialize IndexedDB', { error: errorMessage });
+            log$d.debug('Failed to initialize IndexedDB', { error: errorMessage });
             // Check if this is a version conflict error
             if (this.isVersionConflictError(errorMessage)) {
                 await this.handleVersionConflict();
@@ -4221,32 +4221,32 @@ class WebCacheAdapter {
     async openDatabase() {
         return await openDB(WebCacheAdapter.DB_NAME, WebCacheAdapter.DB_VERSION, {
             upgrade: (db, oldVersion, newVersion, transaction) => {
-                log$a.debug('Database upgrade needed', { oldVersion, newVersion });
+                log$d.debug('Database upgrade needed', { oldVersion, newVersion });
                 this.handleUpgrade(db, oldVersion, newVersion, transaction);
             },
             blocked: () => {
-                log$a.debug('Database blocked - another tab may be open');
+                log$d.debug('Database blocked - another tab may be open');
             },
             blocking: () => {
-                log$a.debug('Database blocking - will close connection');
+                log$d.debug('Database blocking - will close connection');
                 if (this.db) {
                     this.db.close();
                     this.db = null;
                 }
             },
             terminated: () => {
-                log$a.debug('Database connection terminated unexpectedly');
+                log$d.debug('Database connection terminated unexpectedly');
                 this.db = null;
             },
         });
     }
     handleUpgrade(db, oldVersion, newVersion, transaction) {
-        log$a.debug('Handling database upgrade', { oldVersion, newVersion });
+        log$d.debug('Handling database upgrade', { oldVersion, newVersion });
         // Create cache store if it doesn't exist (initial setup)
         if (!db.objectStoreNames.contains(WebCacheAdapter.STORE_NAME)) {
             const store = db.createObjectStore(WebCacheAdapter.STORE_NAME, { keyPath: 'key' });
             store.createIndex('timestamp', 'timestamp', { unique: false });
-            log$a.debug('Created cache store and timestamp index');
+            log$d.debug('Created cache store and timestamp index');
         }
         // Handle migration from version 1 to 2
         if (oldVersion < 2) {
@@ -4257,16 +4257,16 @@ class WebCacheAdapter {
                 try {
                     if (store.indexNames.contains(indexName)) {
                         store.deleteIndex(indexName);
-                        log$a.debug(`Removed unused index: ${indexName}`);
+                        log$d.debug(`Removed unused index: ${indexName}`);
                     }
                 }
                 catch (error) {
                     // Ignore errors if indexes don't exist
-                    log$a.debug(`Warning: Could not remove index ${indexName}`, error);
+                    log$d.debug(`Warning: Could not remove index ${indexName}`, error);
                 }
             });
         }
-        log$a.debug('Database upgrade completed');
+        log$d.debug('Database upgrade completed');
     }
     isVersionConflictError(errorMessage) {
         return (errorMessage.includes('less than the existing version') ||
@@ -4274,7 +4274,7 @@ class WebCacheAdapter {
             errorMessage.includes('VersionError'));
     }
     async handleVersionConflict() {
-        log$a.debug('Handling version conflict, attempting recovery...');
+        log$d.debug('Handling version conflict, attempting recovery...');
         if (this.retryCount >= this.maxRetries) {
             throw new Error('Failed to resolve IndexedDB version conflict after multiple attempts');
         }
@@ -4286,19 +4286,19 @@ class WebCacheAdapter {
                 this.db = null;
             }
             // Delete the problematic database
-            log$a.debug('Deleting problematic database to resolve version conflict');
+            log$d.debug('Deleting problematic database to resolve version conflict');
             await deleteDB(WebCacheAdapter.DB_NAME);
             // Wait a bit for the deletion to complete
             await new Promise((resolve) => setTimeout(resolve, 200));
             // Try to open the database again
-            log$a.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
+            log$d.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
             this.db = await this.openDatabase();
-            log$a.debug('Successfully recovered from version conflict');
+            log$d.debug('Successfully recovered from version conflict');
             this.retryCount = 0; // Reset retry count on success
         }
         catch (retryError) {
             const retryErrorMessage = retryError instanceof Error ? retryError.message : 'Unknown error';
-            log$a.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
+            log$d.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
             if (this.retryCount < this.maxRetries) {
                 // Try again
                 await this.handleVersionConflict();
@@ -4310,7 +4310,7 @@ class WebCacheAdapter {
     }
     async get(key) {
         await this.ensureInitialized();
-        log$a.debug('Getting cache item', { key });
+        log$d.debug('Getting cache item', { key });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4336,7 +4336,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$a.debug('Error getting cache item', { key, error });
+            log$d.debug('Error getting cache item', { key, error });
             return null; // Return null on error instead of throwing
         }
     }
@@ -4358,7 +4358,7 @@ class WebCacheAdapter {
             if (compressionResult.compressed) {
                 finalData = compressionResult.data;
                 isCompressed = true;
-                log$a.debug('Compression result', {
+                log$d.debug('Compression result', {
                     key,
                     originalSize: compressionResult.originalSize,
                     compressedSize: compressionResult.compressedSize,
@@ -4367,7 +4367,7 @@ class WebCacheAdapter {
                 });
             }
         }
-        log$a.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
+        log$d.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
         const storedItem = {
             key,
             data: finalData,
@@ -4380,7 +4380,7 @@ class WebCacheAdapter {
             await store.put(storedItem);
         }
         catch (error) {
-            log$a.debug('Error setting cache item', { key, error });
+            log$d.debug('Error setting cache item', { key, error });
             // Silently fail for cache writes
         }
     }
@@ -4388,7 +4388,7 @@ class WebCacheAdapter {
         if (items.length === 0)
             return;
         await this.ensureInitialized();
-        log$a.debug('Batch setting items', { count: items.length });
+        log$d.debug('Batch setting items', { count: items.length });
         try {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
@@ -4398,10 +4398,10 @@ class WebCacheAdapter {
                 return store.put(storedItem);
             });
             await Promise.all(promises);
-            log$a.debug('Batch operation completed', { count: items.length });
+            log$d.debug('Batch operation completed', { count: items.length });
         }
         catch (error) {
-            log$a.debug('Error in batch operation', { count: items.length, error });
+            log$d.debug('Error in batch operation', { count: items.length, error });
             // Silently fail for batch writes
         }
     }
@@ -4436,10 +4436,10 @@ class WebCacheAdapter {
             const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
             const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
             await store.clear();
-            log$a.debug('Cache cleared successfully');
+            log$d.debug('Cache cleared successfully');
         }
         catch (error) {
-            log$a.debug('Error clearing cache', error);
+            log$d.debug('Error clearing cache', error);
             // Silently fail for cache clear
         }
     }
@@ -4465,7 +4465,7 @@ class WebCacheAdapter {
             };
         }
         catch (error) {
-            log$a.debug('Error getting cache size', error);
+            log$d.debug('Error getting cache size', error);
             return {
                 entries: 0,
                 bytes: 0,
@@ -4490,7 +4490,7 @@ class WebCacheAdapter {
             return allKeys.filter((key) => regex.test(key));
         }
         catch (error) {
-            log$a.debug('Error getting cache keys', error);
+            log$d.debug('Error getting cache keys', error);
             return [];
         }
     }
@@ -4503,7 +4503,7 @@ class WebCacheAdapter {
             return true;
         }
         catch (error) {
-            log$a.debug('Error deleting cache item', { key, error });
+            log$d.debug('Error deleting cache item', { key, error });
             return false;
         }
     }
@@ -4515,7 +4515,7 @@ class WebCacheAdapter {
             await this.initPromise;
         }
         catch (error) {
-            log$a.debug('Failed to ensure initialization', error);
+            log$d.debug('Failed to ensure initialization', error);
             // Reset and try once more
             this.initPromise = null;
             this.db = null;
@@ -4534,7 +4534,7 @@ WebCacheAdapter.DB_NAME = 'acube_cache';
 WebCacheAdapter.DB_VERSION = 2;
 WebCacheAdapter.STORE_NAME = 'cache_entries';
 
-const log$9 = createPrefixedLogger('CACHE-LOADER');
+const log$c = createPrefixedLogger('CACHE-LOADER');
 function loadCacheAdapter(platform) {
     try {
         switch (platform) {
@@ -4566,7 +4566,7 @@ function loadCacheAdapter(platform) {
         }
     }
     catch (error) {
-        log$9.warn(`Cache adapter not available for platform ${platform}:`, error);
+        log$c.warn(`Cache adapter not available for platform ${platform}:`, error);
         return undefined;
     }
 }
@@ -4623,7 +4623,7 @@ class BaseSecureStorageAdapter {
     }
 }
 
-const log$8 = createPrefixedLogger('NETWORK-BASE');
+const log$b = createPrefixedLogger('NETWORK-BASE');
 class NetworkBase {
     constructor(initialOnline = true, debounceMs = 300) {
         this.destroy$ = new Subject();
@@ -4643,14 +4643,14 @@ class NetworkBase {
         const current = this.statusSubject.getValue();
         if (current.online !== online) {
             this.statusSubject.next({ online, timestamp: Date.now() });
-            log$8.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
+            log$b.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
         }
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
         this.statusSubject.complete();
-        log$8.debug('Network monitor destroyed');
+        log$b.debug('Network monitor destroyed');
     }
 }
 
@@ -4710,7 +4710,7 @@ class NodeSecureStorageAdapter extends BaseSecureStorageAdapter {
     }
 }
 
-const log$7 = createPrefixedLogger('RN-STORAGE');
+const log$a = createPrefixedLogger('RN-STORAGE');
 /**
  * React Native storage adapter using AsyncStorage
  * Note: Uses native batch operations for better performance (not base class)
@@ -4742,7 +4742,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getItem(key);
         }
         catch (error) {
-            log$7.error('Failed to get item from AsyncStorage:', error);
+            log$a.error('Failed to get item from AsyncStorage:', error);
             return null;
         }
     }
@@ -4783,7 +4783,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getAllKeys();
         }
         catch (error) {
-            log$7.error('Failed to get all keys:', error);
+            log$a.error('Failed to get all keys:', error);
             return [];
         }
     }
@@ -4800,7 +4800,7 @@ class ReactNativeStorageAdapter {
             return result;
         }
         catch (error) {
-            log$7.error('Failed to get multiple items:', error);
+            log$a.error('Failed to get multiple items:', error);
             const result = {};
             keys.forEach((key) => {
                 result[key] = null;
@@ -4850,7 +4850,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$7.debug('expo-secure-store not available, trying react-native-keychain');
+            log$a.debug('expo-secure-store not available, trying react-native-keychain');
         }
         try {
             const Keychain = require('react-native-keychain');
@@ -4859,7 +4859,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$7.error('react-native-keychain not available');
+            log$a.error('react-native-keychain not available');
         }
         throw new Error('No secure storage available. Please install expo-secure-store or react-native-keychain');
     }
@@ -4877,7 +4877,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             }
         }
         catch (error) {
-            log$7.error('Failed to get secure item:', error);
+            log$a.error('Failed to get secure item:', error);
         }
         return null;
     }
@@ -4914,10 +4914,10 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
         }
     }
     async clear() {
-        log$7.warn('Clear all secure items not fully implemented for React Native');
+        log$a.warn('Clear all secure items not fully implemented for React Native');
     }
     async getAllKeys() {
-        log$7.warn('Get all secure keys not implemented for React Native');
+        log$a.warn('Get all secure keys not implemented for React Native');
         return [];
     }
     async isAvailable() {
@@ -5135,7 +5135,7 @@ class NodeNetworkMonitor extends NetworkBase {
     }
 }
 
-const log$6 = createPrefixedLogger('RN-NETWORK');
+const log$9 = createPrefixedLogger('RN-NETWORK');
 /**
  * React Native network monitor using RxJS
  * Supports both @react-native-community/netinfo and expo-network
@@ -5148,7 +5148,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         this.moduleReady$ = new Subject();
         this.isExpo = detectPlatform().isExpo;
         this.init().catch((error) => {
-            log$6.error('Network monitor initialization failed:', error);
+            log$9.error('Network monitor initialization failed:', error);
         });
     }
     async init() {
@@ -5167,10 +5167,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('@react-native-community/netinfo');
             this.netInfoModule = module.default || module;
-            log$6.debug('Loaded @react-native-community/netinfo module');
+            log$9.debug('Loaded @react-native-community/netinfo module');
         }
         catch (error) {
-            log$6.error('Failed to load React Native NetInfo module:', error);
+            log$9.error('Failed to load React Native NetInfo module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5178,10 +5178,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('expo-network');
             this.netInfoModule = module.default || module;
-            log$6.debug('Loaded expo-network module');
+            log$9.debug('Loaded expo-network module');
         }
         catch (error) {
-            log$6.error('Failed to load Expo Network module:', error);
+            log$9.error('Failed to load Expo Network module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5198,16 +5198,16 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             }
             const online = !!(state.isConnected && state.isInternetReachable !== false);
             this.updateStatus(online);
-            log$6.debug('Initial network state:', online ? 'online' : 'offline');
+            log$9.debug('Initial network state:', online ? 'online' : 'offline');
         }
         catch (error) {
-            log$6.warn('Could not fetch initial network state:', error);
+            log$9.warn('Could not fetch initial network state:', error);
         }
     }
     subscribeToStateChanges() {
         if (!this.netInfoModule)
             return;
-        log$6.debug('Subscribing to network state changes');
+        log$9.debug('Subscribing to network state changes');
         const handleState = (state) => {
             const online = !!(state.isConnected && (state.isInternetReachable ?? true));
             this.updateStatus(online);
@@ -5249,7 +5249,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             };
         }
         catch (error) {
-            log$6.error('Failed to fetch detailed network info:', error);
+            log$9.error('Failed to fetch detailed network info:', error);
             return null;
         }
     }
@@ -5385,7 +5385,7 @@ class CertificateValidator {
     }
 }
 
-const log$5 = createPrefixedLogger('RN-MTLS');
+const log$8 = createPrefixedLogger('RN-MTLS');
 /**
  * React Native mTLS Adapter using @a-cube-io/expo-mutual-tls
  */
@@ -5407,7 +5407,7 @@ class ReactNativeMTLSAdapter {
             this.expoMTLS = ExpoMutualTls;
             // Set up debug logging with the correct event signature
             const debugListener = ExpoMutualTls.onDebugLog((event) => {
-                log$5.debug(`${event.type}: ${event.message}`, {
+                log$8.debug(`${event.type}: ${event.message}`, {
                     method: event.method,
                     url: event.url,
                     statusCode: event.statusCode,
@@ -5417,28 +5417,28 @@ class ReactNativeMTLSAdapter {
             this.eventListeners.push(debugListener);
             // Set up error logging with the correct event signature
             const errorListener = ExpoMutualTls.onError((event) => {
-                log$5.error(event.message, {
+                log$8.error(event.message, {
                     code: event.code,
                 });
             });
             this.eventListeners.push(errorListener);
             // Set up certificate expiry monitoring with the correct event signature
             const expiryListener = ExpoMutualTls.onCertificateExpiry((event) => {
-                log$5.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
+                log$8.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
                     alias: event.alias,
                     warning: event.warning,
                 });
             });
             this.eventListeners.push(expiryListener);
-            log$5.debug('Expo mTLS module loaded successfully');
+            log$8.debug('Expo mTLS module loaded successfully');
         }
         catch (error) {
-            log$5.warn('@a-cube-io/expo-mutual-tls not available:', error);
+            log$8.warn('@a-cube-io/expo-mutual-tls not available:', error);
         }
     }
     async isMTLSSupported() {
         const supported = this.expoMTLS !== null;
-        log$5.debug('mTLS support check:', {
+        log$8.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             moduleAvailable: !!this.expoMTLS,
@@ -5450,7 +5450,7 @@ class ReactNativeMTLSAdapter {
             throw new MTLSError(MTLSErrorType$1.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         this.config = config;
-        log$5.debug('Initialized with config:', {
+        log$8.debug('Initialized with config:', {
             baseUrl: config.baseUrl,
             port: config.port,
             timeout: config.timeout,
@@ -5464,7 +5464,7 @@ class ReactNativeMTLSAdapter {
         if (!this.config) {
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
         }
-        log$5.debug('Configuring certificate:', {
+        log$8.debug('Configuring certificate:', {
             format: certificateData.format,
             hasPassword: !!certificateData.password,
             certificateLength: certificateData.certificate.length,
@@ -5481,14 +5481,14 @@ class ReactNativeMTLSAdapter {
                 'client-key-service', // keyService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$5.debug('PEM services configured:', configResult);
+                log$8.debug('PEM services configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `PEM configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the actual PEM certificate and private key
                 const storeResult = await this.expoMTLS.storePEM(certificateData.certificate, certificateData.privateKey, certificateData.password // passphrase (optional)
                 );
-                log$5.debug('PEM certificate store result:', storeResult);
+                log$8.debug('PEM certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
                 }
@@ -5501,14 +5501,14 @@ class ReactNativeMTLSAdapter {
                 const configResult = await this.expoMTLS.configureP12('client-p12-service', // keychainService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$5.debug('P12 service configured:', configResult);
+                log$8.debug('P12 service configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, `P12 configuration failed: ${configResult.state}`);
                 }
                 // Step 2: Store the P12 certificate data
                 const storeResult = await this.expoMTLS.storeP12(certificateData.certificate, // P12 data in certificate field
                 certificateData.password);
-                log$5.debug('P12 certificate store result:', storeResult);
+                log$8.debug('P12 certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
                 }
@@ -5522,7 +5522,7 @@ class ReactNativeMTLSAdapter {
             if (error instanceof MTLSError) {
                 throw error;
             }
-            log$5.error('Certificate configuration failed:', error);
+            log$8.error('Certificate configuration failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
@@ -5533,38 +5533,38 @@ class ReactNativeMTLSAdapter {
         try {
             // Use static method call
             const hasCert = await this.expoMTLS.hasCertificate();
-            log$5.debug('Certificate availability check:', hasCert);
+            log$8.debug('Certificate availability check:', hasCert);
             return hasCert;
         }
         catch (error) {
-            log$5.error('Certificate check failed:', error);
+            log$8.error('Certificate check failed:', error);
             return false;
         }
     }
     async getCertificateInfo() {
         if (!this.expoMTLS) {
-            log$5.debug('Certificate info requested but module not available');
+            log$8.debug('Certificate info requested but module not available');
             return null;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$5.debug('No certificate stored');
+                log$8.debug('No certificate stored');
                 return null;
             }
             // Use getCertificatesInfo to retrieve information about stored certificates
             const result = await this.expoMTLS.getCertificatesInfo();
             if (!result || !result.certificates || result.certificates.length === 0) {
-                log$5.debug('No certificate information available');
+                log$8.debug('No certificate information available');
                 return null;
             }
             // Get the first certificate (primary client certificate)
             const cert = result.certificates[0];
             if (!cert) {
-                log$5.debug('Certificate data is empty');
+                log$8.debug('Certificate data is empty');
                 return null;
             }
-            log$5.debug('Retrieved certificate info:', {
+            log$8.debug('Retrieved certificate info:', {
                 subject: cert.subject.commonName,
                 issuer: cert.issuer.commonName,
                 validFrom: new Date(cert.validFrom),
@@ -5583,7 +5583,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$5.error('Failed to get certificate info:', error);
+            log$8.error('Failed to get certificate info:', error);
             return null;
         }
     }
@@ -5594,7 +5594,7 @@ class ReactNativeMTLSAdapter {
      */
     async parseCertificateData(certificateData) {
         if (!this.expoMTLS) {
-            log$5.debug('Parse certificate: Module not available');
+            log$8.debug('Parse certificate: Module not available');
             return null;
         }
         try {
@@ -5611,14 +5611,14 @@ class ReactNativeMTLSAdapter {
             else {
                 throw new MTLSError(MTLSErrorType$1.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
-            log$5.debug('Certificate parsed successfully:', {
+            log$8.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
                 subjects: result.certificates.map((cert) => cert.subject.commonName),
             });
             return result;
         }
         catch (error) {
-            log$5.error('Failed to parse certificate:', error);
+            log$8.error('Failed to parse certificate:', error);
             if (error instanceof MTLSError) {
                 throw error;
             }
@@ -5633,7 +5633,7 @@ class ReactNativeMTLSAdapter {
         if (!hasCert) {
             throw new MTLSError(MTLSErrorType$1.CERTIFICATE_NOT_FOUND, 'No certificate configured');
         }
-        log$5.debug('Making mTLS request:', {
+        log$8.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
             url: requestConfig.url,
             headers: requestConfig.headers,
@@ -5641,7 +5641,7 @@ class ReactNativeMTLSAdapter {
             responseType: requestConfig.responseType,
         });
         if (requestConfig.data) {
-            log$5.debug('mTLS request body:', requestConfig.data);
+            log$8.debug('mTLS request body:', requestConfig.data);
         }
         try {
             const response = await this.expoMTLS.request(requestConfig.url, {
@@ -5650,7 +5650,7 @@ class ReactNativeMTLSAdapter {
                 body: requestConfig.data ? JSON.stringify(requestConfig.data) : undefined,
                 responseType: requestConfig.responseType,
             });
-            log$5.debug('mTLS request successful:', response);
+            log$8.debug('mTLS request successful:', response);
             if (!response.success) {
                 throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, `mTLS request failed: ${response.statusMessage} (${response.statusCode})`, undefined, response.statusCode);
             }
@@ -5662,7 +5662,7 @@ class ReactNativeMTLSAdapter {
                     data = JSON.parse(response.body);
                 }
                 catch (parseError) {
-                    log$5.warn('Failed to parse JSON response:', parseError);
+                    log$8.warn('Failed to parse JSON response:', parseError);
                     // If parsing fails, keep raw body
                 }
             }
@@ -5679,7 +5679,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$5.error('mTLS request failed:', error);
+            log$8.error('mTLS request failed:', error);
             throw new MTLSError(MTLSErrorType$1.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
@@ -5692,18 +5692,18 @@ class ReactNativeMTLSAdapter {
      */
     async testConnection() {
         if (!this.expoMTLS || !this.config) {
-            log$5.debug('Diagnostic test: No mTLS module or config available');
+            log$8.debug('Diagnostic test: No mTLS module or config available');
             return false;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$5.debug('Diagnostic test: No certificate configured');
+                log$8.debug('Diagnostic test: No certificate configured');
                 return false;
             }
-            log$5.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
+            log$8.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
             const result = await this.expoMTLS.testConnection(this.config.baseUrl);
-            log$5.debug('Diagnostic test result (NOT validation):', {
+            log$8.debug('Diagnostic test result (NOT validation):', {
                 success: result.success,
                 statusCode: result.statusCode,
                 statusMessage: result.statusMessage,
@@ -5714,13 +5714,13 @@ class ReactNativeMTLSAdapter {
             return result.success;
         }
         catch (error) {
-            log$5.warn('Diagnostic test failed (this is expected):', error);
+            log$8.warn('Diagnostic test failed (this is expected):', error);
             return false;
         }
     }
     async removeCertificate() {
         if (!this.expoMTLS) {
-            log$5.debug('Remove certificate: Module not available');
+            log$8.debug('Remove certificate: Module not available');
             return;
         }
         try {
@@ -5729,10 +5729,10 @@ class ReactNativeMTLSAdapter {
             this.isConfigured = false;
             // Cleanup event listeners
             this.cleanupEventListeners();
-            log$5.debug('Certificate removed successfully');
+            log$8.debug('Certificate removed successfully');
         }
         catch (error) {
-            log$5.error('Failed to remove certificate:', error);
+            log$8.error('Failed to remove certificate:', error);
             throw new MTLSError(MTLSErrorType$1.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
@@ -5741,7 +5741,7 @@ class ReactNativeMTLSAdapter {
      */
     cleanupEventListeners() {
         if (this.eventListeners.length > 0) {
-            log$5.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
+            log$8.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
         }
         // Remove individual listeners if they have remove methods
         this.eventListeners.forEach((listener) => {
@@ -5778,7 +5778,7 @@ class ReactNativeMTLSAdapter {
     }
 }
 
-const log$4 = createPrefixedLogger('WEB-MTLS');
+const log$7 = createPrefixedLogger('WEB-MTLS');
 /**
  * Web mTLS Adapter - Graceful fallback for web browsers
  *
@@ -5792,13 +5792,13 @@ const log$4 = createPrefixedLogger('WEB-MTLS');
  */
 class WebMTLSAdapter {
     constructor() {
-        log$4.warn('Web browsers do not support programmatic mTLS configuration');
-        log$4.info('Use JWT authentication or configure client certificates in browser settings');
+        log$7.warn('Web browsers do not support programmatic mTLS configuration');
+        log$7.info('Use JWT authentication or configure client certificates in browser settings');
     }
     async isMTLSSupported() {
         // mTLS is not supported programmatically in web browsers
         const supported = false;
-        log$4.debug('mTLS support check:', {
+        log$7.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             reason: 'Browser security model prevents programmatic certificate configuration',
@@ -5807,14 +5807,14 @@ class WebMTLSAdapter {
         return supported;
     }
     async initialize(config) {
-        log$4.warn('Initialized but mTLS not available in web browsers:', {
+        log$7.warn('Initialized but mTLS not available in web browsers:', {
             baseUrl: config.baseUrl,
             port: config.port,
             recommendation: 'Use standard HTTPS with JWT authentication',
         });
     }
     async configureCertificate(certificateData) {
-        log$4.error('Certificate configuration attempted:', {
+        log$7.error('Certificate configuration attempted:', {
             format: certificateData.format,
             reason: 'Not supported in web browsers',
             alternatives: [
@@ -5829,15 +5829,15 @@ class WebMTLSAdapter {
     }
     async hasCertificate() {
         // We cannot detect if the browser has certificates configured
-        log$4.debug('Certificate availability check: Cannot detect browser certificates programmatically');
+        log$7.debug('Certificate availability check: Cannot detect browser certificates programmatically');
         return false;
     }
     async getCertificateInfo() {
-        log$4.debug('Certificate info requested: Not accessible in web browsers');
+        log$7.debug('Certificate info requested: Not accessible in web browsers');
         return null;
     }
     async request(requestConfig) {
-        log$4.error('mTLS request attempted:', {
+        log$7.error('mTLS request attempted:', {
             method: requestConfig.method,
             url: requestConfig.url,
             reason: 'Not supported in web browsers',
@@ -5852,11 +5852,11 @@ class WebMTLSAdapter {
             'are properly configured in the browser certificate store.');
     }
     async testConnection() {
-        log$4.debug('Connection test: mTLS not available in web browsers');
+        log$7.debug('Connection test: mTLS not available in web browsers');
         return false;
     }
     async removeCertificate() {
-        log$4.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
+        log$7.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
         // No-op - cannot remove certificates programmatically in browsers
     }
     /**
@@ -5864,7 +5864,7 @@ class WebMTLSAdapter {
      * Always returns null for web browsers as mTLS is not supported
      */
     getBaseUrl() {
-        log$4.debug('Base URL requested: Not supported in web browsers');
+        log$7.debug('Base URL requested: Not supported in web browsers');
         return null;
     }
     getPlatformInfo() {
@@ -5897,7 +5897,7 @@ class WebMTLSAdapter {
     }
 }
 
-const log$3 = createPrefixedLogger('MTLS-LOADER');
+const log$6 = createPrefixedLogger('MTLS-LOADER');
 function loadMTLSAdapter(platform, config) {
     try {
         let adapter;
@@ -5931,7 +5931,7 @@ function loadMTLSAdapter(platform, config) {
         return adapter;
     }
     catch (error) {
-        log$3.warn(`mTLS adapter not available for platform ${platform}:`, error);
+        log$6.warn(`mTLS adapter not available for platform ${platform}:`, error);
         return null;
     }
 }
@@ -5941,7 +5941,7 @@ async function initializeAdapterAsync(adapter, config) {
         if (isSupported) {
             await adapter.initialize(config);
             const platformInfo = adapter.getPlatformInfo();
-            log$3.debug('mTLS adapter initialized:', {
+            log$6.debug('mTLS adapter initialized:', {
                 platform: platformInfo.platform,
                 mtlsSupported: platformInfo.mtlsSupported,
                 certificateStorage: platformInfo.certificateStorage,
@@ -5950,20 +5950,20 @@ async function initializeAdapterAsync(adapter, config) {
         }
     }
     catch (error) {
-        log$3.warn('Failed to initialize mTLS adapter:', error);
+        log$6.warn('Failed to initialize mTLS adapter:', error);
     }
 }
 
-const log$2 = createPrefixedLogger('ADAPTER-LOADER');
+const log$5 = createPrefixedLogger('ADAPTER-LOADER');
 function loadPlatformAdapters(options = {}) {
     const { mtlsConfig } = options;
     const { platform } = detectPlatform();
-    log$2.debug('Loading adapters for platform:', platform);
+    log$5.debug('Loading adapters for platform:', platform);
     const storageAdapters = loadStorageAdapters(platform);
     const networkMonitor = loadNetworkMonitor(platform);
     const cache = loadCacheAdapter(platform);
     const mtls = loadMTLSAdapter(platform, mtlsConfig);
-    log$2.debug('Adapters loaded:', {
+    log$5.debug('Adapters loaded:', {
         platform,
         hasStorage: !!storageAdapters.storage,
         hasSecureStorage: !!storageAdapters.secureStorage,
@@ -6077,10 +6077,12 @@ class ACubeSDKError extends Error {
 
 const DI_TOKENS = {
     HTTP_PORT: Symbol('HTTP_PORT'),
+    BASE_HTTP_PORT: Symbol('BASE_HTTP_PORT'),
     STORAGE_PORT: Symbol('STORAGE_PORT'),
     SECURE_STORAGE_PORT: Symbol('SECURE_STORAGE_PORT'),
     NETWORK_PORT: Symbol('NETWORK_PORT'),
     CACHE_PORT: Symbol('CACHE_PORT'),
+    CACHE_KEY_GENERATOR: Symbol('CACHE_KEY_GENERATOR'),
     MTLS_PORT: Symbol('MTLS_PORT'),
     TOKEN_STORAGE_PORT: Symbol('TOKEN_STORAGE_PORT'),
     RECEIPT_REPOSITORY: Symbol('RECEIPT_REPOSITORY'),
@@ -6310,7 +6312,7 @@ class ReceiptRepositoryImpl {
         if (format === 'pdf') {
             const response = await this.http.get(`/mf1/receipts/${receiptUuid}/details`, {
                 headers: { Accept: 'application/pdf' },
-                responseType: 'blob',
+                responseType: 'arraybuffer',
             });
             return response.data;
         }
@@ -7073,7 +7075,465 @@ class TelemetryRepositoryImpl {
     }
 }
 
-const log$1 = createPrefixedLogger('HTTP-MTLS');
+const log$4 = createPrefixedLogger('CACHE-KEY');
+const URL_PATTERNS = [
+    // Receipt (mf1) - specific patterns first
+    {
+        pattern: /^\/mf1\/receipts\/([^/]+)\/returnable-items$/,
+        resource: 'receipt',
+        action: 'returnable',
+    },
+    {
+        pattern: /^\/mf1\/receipts\/([^/]+)\/details$/,
+        resource: 'receipt',
+        action: 'details',
+    },
+    { pattern: /^\/mf1\/receipts\/([^/]+)$/, resource: 'receipt' },
+    {
+        pattern: /^\/mf1\/point-of-sales\/([^/]+)\/receipts$/,
+        resource: 'receipt',
+        parent: 'point-of-sale',
+        isList: true,
+    },
+    { pattern: /^\/mf1\/receipts$/, resource: 'receipt', isList: true },
+    // Merchant (mf2)
+    { pattern: /^\/mf2\/merchants\/([^/]+)$/, resource: 'merchant' },
+    { pattern: /^\/mf2\/merchants$/, resource: 'merchant', isList: true },
+    // Cashier (mf1)
+    { pattern: /^\/mf1\/cashiers\/me$/, resource: 'cashier', action: 'me' },
+    { pattern: /^\/mf1\/cashiers\/([^/]+)$/, resource: 'cashier' },
+    { pattern: /^\/mf1\/cashiers$/, resource: 'cashier', isList: true },
+    // Cash Register (mf1)
+    { pattern: /^\/mf1\/cash-registers\/([^/]+)$/, resource: 'cash-register' },
+    { pattern: /^\/mf1\/cash-registers$/, resource: 'cash-register', isList: true },
+    // Point of Sale (mf1)
+    { pattern: /^\/mf1\/point-of-sales\/([^/]+)$/, resource: 'point-of-sale' },
+    { pattern: /^\/mf1\/point-of-sales$/, resource: 'point-of-sale', isList: true },
+    // Nested resources under merchant (mf2)
+    {
+        pattern: /^\/mf2\/merchants\/([^/]+)\/suppliers\/([^/]+)$/,
+        resource: 'supplier',
+        parent: 'merchant',
+    },
+    {
+        pattern: /^\/mf2\/merchants\/([^/]+)\/suppliers$/,
+        resource: 'supplier',
+        parent: 'merchant',
+        isList: true,
+    },
+    {
+        pattern: /^\/mf2\/merchants\/([^/]+)\/daily-reports/,
+        resource: 'daily-report',
+        parent: 'merchant',
+        isList: true,
+    },
+    {
+        pattern: /^\/mf2\/merchants\/([^/]+)\/journals/,
+        resource: 'journal',
+        parent: 'merchant',
+        isList: true,
+    },
+    // PEM (mf2)
+    {
+        pattern: /^\/mf2\/point-of-sales\/([^/]+)\/certificates$/,
+        resource: 'pem',
+        action: 'certificates',
+    },
+    { pattern: /^\/mf2\/point-of-sales\/([^/]+)$/, resource: 'pem' },
+    // Others
+    { pattern: /^\/mf1\/notifications/, resource: 'notification', isList: true },
+    {
+        pattern: /^\/mf1\/point-of-sales\/([^/]+)\/telemetry$/,
+        resource: 'telemetry',
+    },
+];
+const DEFAULT_TTL_CONFIG = {
+    // Data that rarely changes - 30 min TTL for items only
+    merchant: { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
+    'point-of-sale': { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
+    'cash-register': { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: true },
+    pem: { ttlMs: 30 * 60 * 1000, cacheList: false, cacheItem: false },
+    // Data that changes moderately - 10 min TTL for items only
+    cashier: { ttlMs: 10 * 60 * 1000, cacheList: false, cacheItem: true },
+    supplier: { ttlMs: 10 * 60 * 1000, cacheList: false, cacheItem: true },
+    // Data that can change - 5 min TTL for items only
+    receipt: { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
+    'daily-report': { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
+    journal: { ttlMs: 5 * 60 * 1000, cacheList: false, cacheItem: true },
+    // Real-time data - 1 min TTL
+    notification: { ttlMs: 1 * 60 * 1000, cacheList: false, cacheItem: false },
+    telemetry: { ttlMs: 1 * 60 * 1000, cacheList: false, cacheItem: false },
+};
+const DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes
+class CacheKeyGenerator {
+    constructor(customConfig) {
+        this.config = { ...DEFAULT_TTL_CONFIG, ...customConfig };
+        log$4.info('CacheKeyGenerator initialized with config:', {
+            resources: Object.keys(this.config),
+        });
+    }
+    generate(url, params) {
+        const parsed = this.parseUrl(url);
+        if (!parsed) {
+            // Fallback: use URL as key
+            const paramStr = params ? this.serializeParams(params) : '';
+            const key = paramStr ? `${url}?${paramStr}` : url;
+            log$4.debug('URL not matched, using fallback key:', { url, key });
+            return key;
+        }
+        const { resource, ids, action, isList, parent } = parsed;
+        if (isList) {
+            const paramStr = params ? this.serializeParams(params) : '';
+            const parentPart = parent && ids.length > 0 ? `${parent}=${ids[0]}&` : '';
+            const key = `${resource}:list:${parentPart}${paramStr}`;
+            log$4.debug('Generated list cache key:', { url, key, resource });
+            return key;
+        }
+        // Single item
+        if (ids.length === 0 && action) {
+            // Special case for endpoints like /cashiers/me
+            const key = `${resource}:${action}`;
+            log$4.debug('Generated special action cache key:', { url, key, resource, action });
+            return key;
+        }
+        let key = `${resource}:${ids.join(':')}`;
+        if (action) {
+            key += `:${action}`;
+        }
+        log$4.debug('Generated item cache key:', { url, key, resource, ids, action });
+        return key;
+    }
+    parseResource(url) {
+        const parsed = this.parseUrl(url);
+        return parsed?.resource;
+    }
+    getTTL(url) {
+        const resource = this.parseResource(url);
+        if (!resource) {
+            log$4.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
+            return DEFAULT_TTL;
+        }
+        const ttl = this.config[resource].ttlMs;
+        log$4.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
+        return ttl;
+    }
+    shouldCache(url) {
+        const parsed = this.parseUrl(url);
+        if (!parsed) {
+            log$4.debug('URL not recognized, should not cache:', { url });
+            return false;
+        }
+        const { resource, isList } = parsed;
+        const config = this.config[resource];
+        if (isList) {
+            log$4.debug('List endpoint cache decision:', {
+                url,
+                resource,
+                isList: true,
+                shouldCache: config.cacheList,
+            });
+            return config.cacheList;
+        }
+        log$4.debug('Item endpoint cache decision:', {
+            url,
+            resource,
+            isList: false,
+            shouldCache: config.cacheItem,
+        });
+        return config.cacheItem;
+    }
+    getInvalidationPatterns(url, method) {
+        const parsed = this.parseUrl(url);
+        if (!parsed) {
+            log$4.debug('No patterns to invalidate for URL:', { url, method });
+            return [];
+        }
+        const { resource, ids, parent } = parsed;
+        const patterns = [];
+        // Always invalidate list on mutations
+        if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'DELETE') {
+            if (parent && ids.length > 0) {
+                patterns.push(`${resource}:list:${parent}=${ids[0]}*`);
+            }
+            patterns.push(`${resource}:list:*`);
+        }
+        // Invalidate specific item on PUT/PATCH/DELETE
+        if (method === 'PUT' || method === 'PATCH' || method === 'DELETE') {
+            if (ids.length > 0) {
+                patterns.push(`${resource}:${ids.join(':')}*`);
+            }
+        }
+        // Special cases
+        if (resource === 'cashier' && (method === 'PUT' || method === 'DELETE')) {
+            patterns.push('cashier:me');
+        }
+        log$4.debug('Invalidation patterns:', { url, method, patterns });
+        return patterns;
+    }
+    parseUrl(url) {
+        // Remove query string for pattern matching
+        const urlPath = url.split('?')[0];
+        for (const pattern of URL_PATTERNS) {
+            const match = urlPath?.match(pattern.pattern);
+            if (match) {
+                // Extract IDs from capture groups
+                const ids = match.slice(1).filter(Boolean);
+                return {
+                    resource: pattern.resource,
+                    ids,
+                    action: pattern.action,
+                    isList: pattern.isList,
+                    parent: pattern.parent,
+                };
+            }
+        }
+        return null;
+    }
+    serializeParams(params) {
+        const sortedKeys = Object.keys(params).sort();
+        const parts = [];
+        for (const key of sortedKeys) {
+            const value = params[key];
+            if (value !== undefined && value !== null) {
+                parts.push(`${key}=${String(value)}`);
+            }
+        }
+        return parts.join('&');
+    }
+}
+
+const log$3 = createPrefixedLogger('CACHE');
+class CachingHttpDecorator {
+    constructor(http, cache, keyGenerator, networkMonitor, config = {}) {
+        this.http = http;
+        this.cache = cache;
+        this.keyGenerator = keyGenerator;
+        this.networkMonitor = networkMonitor;
+        this.config = config;
+        this.currentOnlineState = true;
+        this.authToken = null;
+        log$3.info('CachingHttpDecorator initialized', {
+            enabled: config.enabled !== false,
+            hasNetworkMonitor: !!networkMonitor,
+        });
+        this.setupNetworkMonitoring();
+    }
+    setupNetworkMonitoring() {
+        if (this.networkMonitor) {
+            this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
+                if (this.currentOnlineState !== online) {
+                    log$3.info('Network state changed:', { online });
+                }
+                this.currentOnlineState = online;
+            });
+        }
+    }
+    isOnline() {
+        if (this.networkMonitor) {
+            return this.currentOnlineState;
+        }
+        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
+            return navigator.onLine;
+        }
+        return true;
+    }
+    async get(url, config) {
+        const startTime = Date.now();
+        // Check if caching is disabled globally
+        if (this.config.enabled === false) {
+            log$3.debug('GET (cache disabled globally):', { url });
+            return this.http.get(url, config);
+        }
+        // Check if this URL should be cached
+        const shouldCache = this.keyGenerator.shouldCache(url);
+        if (!shouldCache) {
+            log$3.debug('GET (not cacheable - likely a list endpoint):', { url });
+            return this.http.get(url, config);
+        }
+        const cacheKey = this.keyGenerator.generate(url, config?.params);
+        const ttl = this.keyGenerator.getTTL(url);
+        const resource = this.keyGenerator.parseResource(url);
+        log$3.info('GET request starting:', {
+            url,
+            resource,
+            cacheKey,
+            ttlMs: ttl,
+            ttlMin: Math.round(ttl / 60000),
+            params: config?.params,
+        });
+        // Check cache
+        let cached = null;
+        try {
+            cached = await this.cache.get(cacheKey);
+            if (cached) {
+                log$3.debug('Cache entry found:', {
+                    cacheKey,
+                    timestamp: new Date(cached.timestamp).toISOString(),
+                    ageMs: Date.now() - cached.timestamp,
+                });
+            }
+            else {
+                log$3.debug('Cache entry not found:', { cacheKey });
+            }
+        }
+        catch (error) {
+            log$3.warn('Cache lookup failed:', {
+                cacheKey,
+                error: error instanceof Error ? error.message : error,
+            });
+        }
+        if (cached) {
+            const age = Date.now() - cached.timestamp;
+            const isExpired = age >= ttl;
+            log$3.debug('Cache analysis:', {
+                cacheKey,
+                ageMs: age,
+                ageSec: Math.round(age / 1000),
+                ttlMs: ttl,
+                isExpired,
+                isOnline: this.isOnline(),
+            });
+            // If within TTL, return cached data
+            if (!isExpired) {
+                const duration = Date.now() - startTime;
+                log$3.info('CACHE HIT:', {
+                    url,
+                    cacheKey,
+                    ageMs: age,
+                    durationMs: duration,
+                });
+                return {
+                    data: cached.data,
+                    status: 200,
+                    headers: { 'x-cache': 'HIT' },
+                };
+            }
+            // If offline and cache is stale, return stale data
+            if (!this.isOnline()) {
+                const duration = Date.now() - startTime;
+                log$3.info('CACHE STALE (offline):', {
+                    url,
+                    cacheKey,
+                    ageMs: age,
+                    durationMs: duration,
+                });
+                return {
+                    data: cached.data,
+                    status: 200,
+                    headers: { 'x-cache': 'STALE' },
+                };
+            }
+            log$3.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
+        }
+        // Fetch fresh data
+        try {
+            log$3.debug('Fetching from network:', { url });
+            const response = await this.http.get(url, config);
+            // Cache the response
+            try {
+                await this.cache.set(cacheKey, response.data);
+                log$3.debug('Response cached successfully:', { cacheKey });
+            }
+            catch (error) {
+                log$3.error('Failed to cache response:', {
+                    cacheKey,
+                    error: error instanceof Error ? error.message : error,
+                });
+            }
+            const duration = Date.now() - startTime;
+            log$3.info('CACHE MISS (fetched fresh):', {
+                url,
+                cacheKey,
+                status: response.status,
+                durationMs: duration,
+            });
+            return {
+                ...response,
+                headers: { ...response.headers, 'x-cache': 'MISS' },
+            };
+        }
+        catch (error) {
+            // On error, return stale cache if available
+            if (cached) {
+                const duration = Date.now() - startTime;
+                log$3.warn('CACHE STALE (network error):', {
+                    url,
+                    cacheKey,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    durationMs: duration,
+                });
+                return {
+                    data: cached.data,
+                    status: 200,
+                    headers: { 'x-cache': 'STALE' },
+                };
+            }
+            log$3.error('Network error with no cache fallback:', {
+                url,
+                error: error instanceof Error ? error.message : error,
+            });
+            throw error;
+        }
+    }
+    async post(url, data, config) {
+        log$3.info('POST request:', { url });
+        const response = await this.http.post(url, data, config);
+        await this.invalidateRelated(url, 'POST');
+        return response;
+    }
+    async put(url, data, config) {
+        log$3.info('PUT request:', { url });
+        const response = await this.http.put(url, data, config);
+        await this.invalidateRelated(url, 'PUT');
+        return response;
+    }
+    async patch(url, data, config) {
+        log$3.info('PATCH request:', { url });
+        const response = await this.http.patch(url, data, config);
+        await this.invalidateRelated(url, 'PATCH');
+        return response;
+    }
+    async delete(url, config) {
+        log$3.info('DELETE request:', { url });
+        const response = await this.http.delete(url, config);
+        await this.invalidateRelated(url, 'DELETE');
+        return response;
+    }
+    setAuthToken(token) {
+        log$3.debug('Auth token updated:', { hasToken: !!token });
+        this.authToken = token;
+        this.http.setAuthToken(token);
+    }
+    getAuthToken() {
+        return this.authToken;
+    }
+    async invalidateRelated(url, method) {
+        const patterns = this.keyGenerator.getInvalidationPatterns(url, method);
+        if (patterns.length === 0) {
+            log$3.debug('No cache patterns to invalidate:', { url, method });
+            return;
+        }
+        log$3.info('Invalidating cache patterns:', { url, method, patterns });
+        for (const pattern of patterns) {
+            try {
+                await this.cache.invalidate(pattern);
+                log$3.debug('Cache pattern invalidated:', { pattern });
+            }
+            catch (error) {
+                log$3.error('Failed to invalidate pattern:', {
+                    pattern,
+                    error: error instanceof Error ? error.message : error,
+                });
+            }
+        }
+    }
+    destroy() {
+        log$3.debug('CachingHttpDecorator destroyed');
+        this.networkSubscription?.unsubscribe();
+    }
+}
+
+const log$2 = createPrefixedLogger('HTTP-MTLS');
 class AxiosHttpAdapter {
     constructor(config) {
         this.authToken = null;
@@ -7091,11 +7551,11 @@ class AxiosHttpAdapter {
     }
     setMTLSAdapter(adapter) {
         this.mtlsAdapter = adapter;
-        log$1.debug('mTLS adapter configured:', !!adapter);
+        log$2.debug('mTLS adapter configured:', !!adapter);
     }
     setAuthStrategy(strategy) {
         this.authStrategy = strategy;
-        log$1.debug('Auth strategy configured:', !!strategy);
+        log$2.debug('Auth strategy configured:', !!strategy);
     }
     async shouldUseMTLS(url, method) {
         if (!this.mtlsAdapter) {
@@ -7103,7 +7563,7 @@ class AxiosHttpAdapter {
         }
         if (this.authStrategy) {
             const config = await this.authStrategy.determineAuthConfig(url, method);
-            log$1.debug(`Auth config for ${method} ${url}:`, config);
+            log$2.debug(`Auth config for ${method} ${url}:`, config);
             return config.mode === 'mtls';
         }
         // Fallback: use mTLS for mf1/mf2 endpoints if no strategy
@@ -7120,10 +7580,10 @@ class AxiosHttpAdapter {
         };
         if (this.authToken) {
             headers['Authorization'] = `Bearer ${this.authToken}`;
-            log$1.debug('JWT token present for mTLS request');
+            log$2.debug('JWT token present for mTLS request');
         }
         else {
-            log$1.warn('No JWT token for mTLS request');
+            log$2.warn('No JWT token for mTLS request');
         }
         const mtlsConfig = {
             url: fullUrl,
@@ -7132,15 +7592,15 @@ class AxiosHttpAdapter {
             data,
             timeout: config?.timeout,
         };
-        log$1.debug(`mTLS ${method} ${fullUrl}`);
+        log$2.debug(`mTLS ${method} ${fullUrl}`);
         if (data) {
-            log$1.debug('Request body:', data);
+            log$2.debug('Request body:', data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$1.debug(`mTLS Response ${response.status} from ${fullUrl}`);
+            log$2.debug(`mTLS Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$1.debug('Response body:', response.data);
+                log$2.debug('Response body:', response.data);
             }
             return {
                 data: response.data,
@@ -7149,11 +7609,11 @@ class AxiosHttpAdapter {
             };
         }
         catch (error) {
-            log$1.error(`mTLS Response error from ${fullUrl}:`, error);
+            log$2.error(`mTLS Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$1.error('Response body:', axiosError.response.data);
+                    log$2.error('Response body:', axiosError.response.data);
                 }
             }
             throw error;
@@ -7168,32 +7628,36 @@ class AxiosHttpAdapter {
         this.client.interceptors.request.use((config) => {
             if (this.authToken) {
                 config.headers.Authorization = `Bearer ${this.authToken}`;
+                log$2.debug('Adding JWT token to request');
+            }
+            else {
+                log$2.warn('No JWT token available for request:', { url: config.url });
             }
             const method = config.method?.toUpperCase() ?? 'UNKNOWN';
-            log$1.debug(`→ ${method} ${config.url}`);
+            log$2.debug(`→ ${method} ${config.url}`);
             if (config.params && Object.keys(config.params).length > 0) {
-                log$1.debug('Request params:', config.params);
+                log$2.debug('Request params:', config.params);
             }
             if (config.data) {
-                log$1.debug('Request body:', config.data);
+                log$2.debug('Request body:', config.data);
             }
             return config;
         }, (error) => {
-            log$1.error('Request error:', error);
+            log$2.error('Request error:', error);
             return Promise.reject(error);
         });
         this.client.interceptors.response.use((response) => {
             const method = response.config.method?.toUpperCase() ?? 'UNKNOWN';
-            log$1.debug(`← ${method} ${response.status} ${response.config.url}`);
+            log$2.debug(`← ${method} ${response.status} ${response.config.url}`);
             if (response.data) {
-                log$1.debug('Response body:', response.data);
+                log$2.debug('Response body:', response.data);
             }
             return response;
         }, (error) => {
             const method = error.config?.method?.toUpperCase() ?? 'UNKNOWN';
-            log$1.error(`← ${method} ${error.response?.status ?? 'ERR'} ${error.config?.url ?? 'unknown'}`);
+            log$2.error(`← ${method} ${error.response?.status ?? 'ERR'} ${error.config?.url ?? 'unknown'}`);
             if (error.response?.data) {
-                log$1.error('Response body:', error.response.data);
+                log$2.error('Response body:', error.response.data);
             }
             return Promise.reject(error);
         });
@@ -7263,6 +7727,7 @@ class AxiosHttpAdapter {
         return this.mapResponse(response);
     }
     setAuthToken(token) {
+        log$2.info('setAuthToken called:', { hasToken: !!token, tokenPrefix: token?.substring(0, 20) });
         this.authToken = token;
     }
     getAuthToken() {
@@ -7316,6 +7781,7 @@ class SDKFactory {
             baseUrl: config.baseUrl,
             timeout: config.timeout,
         });
+        container.register(DI_TOKENS.BASE_HTTP_PORT, httpAdapter);
         container.register(DI_TOKENS.HTTP_PORT, httpAdapter);
         container.registerFactory(DI_TOKENS.RECEIPT_REPOSITORY, () => {
             const http = container.get(DI_TOKENS.HTTP_PORT);
@@ -7363,6 +7829,23 @@ class SDKFactory {
         });
         return container;
     }
+    static registerCacheServices(container, cache, network) {
+        container.register(DI_TOKENS.CACHE_PORT, cache);
+        if (network) {
+            container.register(DI_TOKENS.NETWORK_PORT, network);
+        }
+        const keyGenerator = new CacheKeyGenerator();
+        container.register(DI_TOKENS.CACHE_KEY_GENERATOR, keyGenerator);
+        const baseHttp = container.get(DI_TOKENS.BASE_HTTP_PORT);
+        const cachingHttp = new CachingHttpDecorator(baseHttp, cache, keyGenerator, network);
+        container.register(DI_TOKENS.HTTP_PORT, cachingHttp);
+    }
+    static getCacheKeyGenerator(container) {
+        if (container.has(DI_TOKENS.CACHE_KEY_GENERATOR)) {
+            return container.get(DI_TOKENS.CACHE_KEY_GENERATOR);
+        }
+        return undefined;
+    }
     static registerAuthServices(container, secureStorage, config) {
         const tokenStorage = new TokenStorageAdapter(secureStorage);
         container.register(DI_TOKENS.TOKEN_STORAGE_PORT, tokenStorage);
@@ -7400,6 +7883,7 @@ class SDKFactory {
     }
 }
 
+const log$1 = createPrefixedLogger('SDK');
 class ACubeSDK {
     constructor(config, customAdapters, events = {}) {
         this.events = events;
@@ -7413,14 +7897,27 @@ class ACubeSDK {
     }
     async initialize() {
         if (this.isInitialized) {
+            log$1.debug('SDK already initialized, skipping');
             return;
         }
+        log$1.info('Initializing SDK', {
+            apiUrl: this.config.getApiUrl(),
+            authUrl: this.config.getAuthUrl(),
+            debugEnabled: this.config.isDebugEnabled(),
+        });
         try {
             if (!this.adapters) {
+                log$1.debug('Loading platform adapters');
                 const mtlsConfig = createACubeMTLSConfig(this.config.getApiUrl(), this.config.getTimeout(), true);
                 this.adapters = loadPlatformAdapters({
                     mtlsConfig,
                 });
+                log$1.info('Platform adapters loaded', {
+                    hasCache: !!this.adapters.cache,
+                    hasNetworkMonitor: !!this.adapters.networkMonitor,
+                    hasMtls: !!this.adapters.mtls,
+                    hasSecureStorage: !!this.adapters.secureStorage,
+                });
             }
             const factoryConfig = {
                 baseUrl: this.config.getApiUrl(),
@@ -7428,11 +7925,25 @@ class ACubeSDK {
                 timeout: this.config.getTimeout(),
                 debugEnabled: this.config.isDebugEnabled(),
             };
+            log$1.debug('Creating DI container');
             this.container = SDKFactory.createContainer(factoryConfig);
+            log$1.debug('Registering auth services');
             SDKFactory.registerAuthServices(this.container, this.adapters.secureStorage, factoryConfig);
+            if (this.adapters.cache) {
+                log$1.info('Registering cache services', {
+                    hasNetworkMonitor: !!this.adapters.networkMonitor,
+                });
+                SDKFactory.registerCacheServices(this.container, this.adapters.cache, this.adapters.networkMonitor);
+            }
+            else {
+                log$1.debug('No cache adapter available, caching disabled');
+            }
+            log$1.debug('Initializing certificate service');
             this.certificateService = new CertificateService(this.adapters.secureStorage);
             const tokenStorage = this.container.get(DI_TOKENS.TOKEN_STORAGE_PORT);
             const httpPort = this.container.get(DI_TOKENS.HTTP_PORT);
+            const baseHttpPort = this.container.get(DI_TOKENS.BASE_HTTP_PORT);
+            log$1.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
                 timeout: this.config.getTimeout(),
@@ -7442,6 +7953,7 @@ class ACubeSDK {
                     this.events.onAuthError?.(new ACubeSDKError('AUTH_ERROR', error.message, error));
                 },
             });
+            log$1.debug('Initializing offline manager');
             const queueEvents = {
                 onOperationAdded: (operation) => {
                     this.events.onOfflineOperationAdded?.(operation.id);
@@ -7460,9 +7972,7 @@ class ACubeSDK {
                 this.currentOnlineState = online;
                 this.events.onNetworkStatusChanged?.(online);
                 if (online && this.offlineManager) {
-                    this.offlineManager.sync().catch(() => {
-                        // Sync errors are handled internally by OfflineManager
-                    });
+                    this.offlineManager.sync().catch(() => { });
                 }
             });
             if (await this.authService.isAuthenticated()) {
@@ -7471,13 +7981,13 @@ class ACubeSDK {
                     httpPort.setAuthToken(token);
                 }
             }
-            // Connect mTLS adapter to HTTP port for /mf1 and /mf2 requests
-            if (this.adapters?.mtls && 'setMTLSAdapter' in httpPort) {
-                const httpWithMtls = httpPort;
+            if (this.adapters?.mtls && 'setMTLSAdapter' in baseHttpPort) {
+                log$1.debug('Connecting mTLS adapter to HTTP port');
+                const httpWithMtls = baseHttpPort;
                 httpWithMtls.setMTLSAdapter(this.adapters.mtls);
             }
-            // Create and connect AuthStrategy
-            if ('setAuthStrategy' in httpPort) {
+            if ('setAuthStrategy' in baseHttpPort) {
+                log$1.debug('Configuring auth strategy');
                 const jwtHandler = new JwtAuthHandler(tokenStorage);
                 const certificatePort = this.certificateService
                     ? {
@@ -7508,7 +8018,7 @@ class ACubeSDK {
                     },
                 };
                 const authStrategy = new AuthStrategy(jwtHandler, mtlsHandler, userProvider, this.adapters?.mtls || null);
-                const httpWithStrategy = httpPort;
+                const httpWithStrategy = baseHttpPort;
                 httpWithStrategy.setAuthStrategy(authStrategy);
             }
             if (this.adapters?.mtls && this.certificateService) {
@@ -7525,13 +8035,22 @@ class ACubeSDK {
                         }
                     }
                 }
-                catch {
-                    // Certificate auto-configuration failed, will retry on demand
+                catch (certError) {
+                    log$1.warn('Certificate auto-configuration failed, will retry on demand', {
+                        error: certError instanceof Error ? certError.message : certError,
+                    });
                 }
             }
             this.isInitialized = true;
+            log$1.info('SDK initialized successfully', {
+                hasCache: !!this.adapters.cache,
+                hasMtls: !!this.adapters.mtls,
+            });
         }
         catch (error) {
+            log$1.error('SDK initialization failed', {
+                error: error instanceof Error ? error.message : error,
+            });
             throw new ACubeSDKError('SDK_INITIALIZATION_ERROR', `Failed to initialize SDK: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
         }
     }
@@ -7585,15 +8104,19 @@ class ACubeSDK {
     }
     async login(credentials) {
         this.ensureInitialized();
+        log$1.info('Login attempt', { email: credentials.email });
         const user = await this.authService.login(credentials);
+        log$1.info('Login successful', { roles: user.roles });
         const token = await this.authService.getAccessToken();
         if (token) {
             this.httpPort.setAuthToken(token);
+            log$1.debug('Auth token set on HTTP port');
         }
         return user;
     }
     async logout() {
         this.ensureInitialized();
+        log$1.info('Logout');
         await this.authService.logout();
         this.httpPort.setAuthToken(null);
     }
@@ -7674,12 +8197,7 @@ class ACubeSDK {
     async clearCertificate() {
         this.ensureInitialized();
         if (this.adapters?.mtls) {
-            try {
-                await this.adapters.mtls.removeCertificate();
-            }
-            catch {
-                // No certificate to remove
-            }
+            await this.adapters.mtls.removeCertificate().catch(() => { });
         }
         if (this.certificateService) {
             await this.certificateService.clearCertificate();
@@ -8014,17 +8532,16 @@ class NotificationService {
 }
 
 const DEFAULT_CONFIG = {
-    cacheKeyPrefix: 'acube_telemetry_',
-    cacheTtlMs: 300000,
+    pollIntervalMs: 60000, // 1 minute default for telemetry
 };
 class TelemetryService {
     get state$() {
         return this.stateSubject.asObservable();
     }
-    constructor(repository, storagePort, networkPort, config) {
+    constructor(repository, networkPort, config, events) {
         this.repository = repository;
-        this.storagePort = storagePort;
         this.networkPort = networkPort;
+        this.events = events;
         this.stateSubject = new BehaviorSubject({
             data: null,
             isCached: false,
@@ -8032,29 +8549,69 @@ class TelemetryService {
             lastFetchedAt: null,
         });
         this.destroy$ = new Subject();
-        this.isOnline = true;
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.setupNetworkMonitoring();
     }
     setupNetworkMonitoring() {
-        this.networkPort.online$.pipe(takeUntil(this.destroy$)).subscribe((online) => {
-            this.isOnline = online;
+        this.networkSubscription = this.networkPort.online$
+            .pipe(startWith(true), pairwise(), filter(([wasOnline, isNowOnline]) => !wasOnline && isNowOnline), takeUntil(this.destroy$))
+            .subscribe(() => {
+            this.triggerSync();
         });
     }
+    startPolling(pemId) {
+        if (this.pollingSubscription) {
+            // If already polling for same pemId, do nothing
+            if (this.currentPemId === pemId) {
+                return;
+            }
+            // If polling for different pemId, stop and restart
+            this.stopPolling();
+        }
+        this.currentPemId = pemId;
+        this.pollingSubscription = interval(this.config.pollIntervalMs)
+            .pipe(startWith(0), switchMap(() => this.fetchTelemetry()), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    stopPolling() {
+        this.pollingSubscription?.unsubscribe();
+        this.pollingSubscription = undefined;
+        this.currentPemId = undefined;
+    }
+    async triggerSync() {
+        if (!this.currentPemId) {
+            return this.stateSubject.value;
+        }
+        return this.fetchTelemetry();
+    }
     async getTelemetry(pemId) {
-        return this.fetchWithFallback(pemId);
+        // Start polling if not already polling for this pemId
+        if (this.currentPemId !== pemId) {
+            this.startPolling(pemId);
+        }
+        return this.stateSubject.value;
     }
     async refreshTelemetry(pemId) {
-        if (!this.isOnline) {
+        // Update pemId and fetch immediately
+        if (this.currentPemId !== pemId) {
+            this.startPolling(pemId);
+        }
+        else {
+            return this.fetchTelemetry();
+        }
+        return this.stateSubject.value;
+    }
+    async fetchTelemetry() {
+        if (!this.currentPemId) {
             return this.stateSubject.value;
         }
         this.stateSubject.next({
             ...this.stateSubject.value,
             isLoading: true,
+            error: undefined,
         });
         try {
-            const data = await this.repository.getTelemetry(pemId);
-            await this.cacheData(pemId, data);
+            const data = await this.repository.getTelemetry(this.currentPemId);
             const newState = {
                 data,
                 isCached: false,
@@ -8062,6 +8619,7 @@ class TelemetryService {
                 lastFetchedAt: Date.now(),
             };
             this.stateSubject.next(newState);
+            this.events?.onTelemetryUpdate?.(data);
             return newState;
         }
         catch (error) {
@@ -8072,89 +8630,25 @@ class TelemetryService {
                 error: errorMessage,
             };
             this.stateSubject.next(newState);
+            if (error instanceof Error) {
+                this.events?.onSyncError?.(error);
+            }
             return newState;
         }
     }
-    async fetchWithFallback(pemId) {
+    clearTelemetry() {
         this.stateSubject.next({
-            ...this.stateSubject.value,
-            isLoading: true,
-        });
-        if (this.isOnline) {
-            try {
-                const data = await this.repository.getTelemetry(pemId);
-                await this.cacheData(pemId, data);
-                const newState = {
-                    data,
-                    isCached: false,
-                    isLoading: false,
-                    lastFetchedAt: Date.now(),
-                };
-                this.stateSubject.next(newState);
-                return newState;
-            }
-            catch (error) {
-                return this.loadFromCache(pemId, error);
-            }
-        }
-        return this.loadFromCache(pemId);
-    }
-    async loadFromCache(pemId, originalError) {
-        const cached = await this.getCachedData(pemId);
-        if (cached && this.isCacheValid(cached.timestamp)) {
-            const newState = {
-                data: cached.data,
-                isCached: true,
-                isLoading: false,
-                lastFetchedAt: cached.timestamp,
-            };
-            this.stateSubject.next(newState);
-            return newState;
-        }
-        const errorMessage = originalError instanceof Error ? originalError.message : 'No cached data available';
-        const newState = {
             data: null,
             isCached: false,
             isLoading: false,
             lastFetchedAt: null,
-            error: errorMessage,
-        };
-        this.stateSubject.next(newState);
-        return newState;
-    }
-    async cacheData(pemId, data) {
-        const cacheKey = this.getCacheKey(pemId);
-        const cached = {
-            data,
-            timestamp: Date.now(),
-        };
-        await this.storagePort.set(cacheKey, JSON.stringify(cached));
-    }
-    async getCachedData(pemId) {
-        const cacheKey = this.getCacheKey(pemId);
-        const stored = await this.storagePort.get(cacheKey);
-        if (!stored) {
-            return null;
-        }
-        try {
-            return JSON.parse(stored);
-        }
-        catch {
-            return null;
-        }
-    }
-    isCacheValid(timestamp) {
-        return Date.now() - timestamp < this.config.cacheTtlMs;
-    }
-    getCacheKey(pemId) {
-        return `${this.config.cacheKeyPrefix}${pemId}`;
-    }
-    clearCache(pemId) {
-        return this.storagePort.remove(this.getCacheKey(pemId));
+        });
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
+        this.pollingSubscription?.unsubscribe();
+        this.networkSubscription?.unsubscribe();
     }
 }
 
@@ -8164,7 +8658,7 @@ class TelemetryService {
  * Provides:
  * - Single initialization point
  * - Observable app state (NORMAL, WARNING, BLOCKED, OFFLINE)
- * - Observable telemetry state
+ * - Observable telemetry state with polling
  * - Simplified services for product use
  *
  * @example
@@ -8173,6 +8667,7 @@ class TelemetryService {
  * SDKManager.configure({
  *   environment: 'sandbox',
  *   notificationPollIntervalMs: 30000,
+ *   telemetryPollIntervalMs: 60000,
  * });
  *
  * // Initialize
@@ -8184,6 +8679,14 @@ class TelemetryService {
  *   console.log('App mode:', state.mode);
  * });
  *
+ * // Start telemetry polling for a specific PEM
+ * manager.startTelemetryPolling('PEM-123');
+ *
+ * // Subscribe to telemetry updates
+ * manager.telemetry$.subscribe(telemetry => {
+ *   console.log('Telemetry:', telemetry);
+ * });
+ *
  * // Cleanup
  * SDKManager.destroy();
  * ```
@@ -8239,43 +8742,40 @@ class SDKManager {
      * Must be called after configure()
      */
     async initialize() {
-        if (this.isInitialized) {
+        if (this.isInitialized)
             return;
-        }
-        // Create and initialize SDK
         this.sdk = new ACubeSDK(this.config, this.adapters, this.events);
         await this.sdk.initialize();
-        // Get required adapters
         const adaptersRef = this.sdk.getAdapters();
         if (!adaptersRef) {
             throw new ACubeSDKError('ADAPTERS_NOT_AVAILABLE', 'Platform adapters not available');
         }
         const networkPort = adaptersRef.networkMonitor;
-        const storagePort = adaptersRef.storage;
-        // Get repositories from SDK
         const notificationRepo = this.sdk.notifications;
         const telemetryRepo = this.sdk.telemetry;
-        // Create NotificationService
         this.notificationService = new NotificationService(notificationRepo, networkPort, {
             pollIntervalMs: this.config.notificationPollIntervalMs ?? 30000,
             defaultPageSize: this.config.notificationPageSize ?? 30,
         });
-        // Create TelemetryService
-        this.telemetryService = new TelemetryService(telemetryRepo, storagePort, networkPort, {
-            cacheTtlMs: this.config.telemetryCacheTtlMs ?? 300000,
+        this.telemetryService = new TelemetryService(telemetryRepo, networkPort, {
+            pollIntervalMs: this.config.telemetryPollIntervalMs ?? 60000,
         });
-        // Create AppStateService
         this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort);
-        // Subscribe to state changes for events
         if (this.events?.onAppStateChanged) {
             this.appStateService.state$.subscribe(this.events.onAppStateChanged);
         }
         if (this.events?.onTelemetryStateChanged) {
             this.telemetryService.state$.subscribe(this.events.onTelemetryStateChanged);
         }
-        // Start notification polling
-        this.notificationService.startPolling();
         this.isInitialized = true;
+        // Only start polling for MERCHANT/CASHIER users (SUPPLIER gets 401 on these endpoints)
+        const user = await this.sdk.getCurrentUser();
+        const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
+        if (canPoll) {
+            this.notificationService.startPolling();
+            await this.startTelemetryPollingAuto();
+        }
+        // AppStateService remains active for all users (handles OFFLINE network state)
     }
     /**
      * Observable stream of app state
@@ -8308,12 +8808,51 @@ class SDKManager {
         return this.appStateService.warning$;
     }
     /**
-     * Observable stream of telemetry state
+     * Observable stream of telemetry state (data, isLoading, isCached, error)
      */
     get telemetryState$() {
         this.ensureInitialized();
         return this.telemetryService.state$;
     }
+    /**
+     * Get the pemId from the installed certificate
+     */
+    async getPemId() {
+        this.ensureInitialized();
+        try {
+            const certInfo = await this.sdk.getCertificatesInfo();
+            return certInfo?.pemId ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Start polling telemetry using the pemId from installed certificate
+     * Returns the pemId if successful, null if no certificate is installed
+     */
+    async startTelemetryPollingAuto() {
+        this.ensureInitialized();
+        const pemId = await this.getPemId();
+        if (pemId) {
+            this.telemetryService.startPolling(pemId);
+        }
+        return pemId;
+    }
+    /**
+     * Start polling telemetry for a specific PEM
+     */
+    startTelemetryPolling(pemId) {
+        this.ensureInitialized();
+        this.telemetryService.startPolling(pemId);
+    }
+    /**
+     * Stop telemetry polling
+     */
+    stopTelemetryPolling() {
+        this.ensureInitialized();
+        this.telemetryService.stopPolling();
+    }
     /**
      * Get simplified services for product use
      */
@@ -8322,7 +8861,6 @@ class SDKManager {
         const sdk = this.sdk;
         const telemetryService = this.telemetryService;
         return {
-            // Business repositories
             receipts: sdk.receipts,
             merchants: sdk.merchants,
             cashiers: sdk.cashiers,
@@ -8332,22 +8870,23 @@ class SDKManager {
             pems: sdk.pems,
             dailyReports: sdk.dailyReports,
             journals: sdk.journals,
-            // Simplified telemetry operations
             telemetry: {
+                startPollingAuto: () => this.startTelemetryPollingAuto(),
+                startPolling: (pemId) => telemetryService.startPolling(pemId),
+                stopPolling: () => telemetryService.stopPolling(),
                 getTelemetry: (pemId) => telemetryService.getTelemetry(pemId),
                 refreshTelemetry: (pemId) => telemetryService.refreshTelemetry(pemId),
-                clearCache: (pemId) => telemetryService.clearCache(pemId),
+                triggerSync: () => telemetryService.triggerSync(),
+                clearTelemetry: () => telemetryService.clearTelemetry(),
+                getPemId: () => this.getPemId(),
             },
-            // Auth operations
             login: (credentials) => sdk.login(credentials),
             logout: () => sdk.logout(),
             getCurrentUser: () => sdk.getCurrentUser(),
             isAuthenticated: () => sdk.isAuthenticated(),
-            // Certificate operations
             storeCertificate: (certificate, privateKey, options) => sdk.storeCertificate(certificate, privateKey, options),
             hasCertificate: () => sdk.hasCertificate(),
             clearCertificate: () => sdk.clearCertificate(),
-            // Network status
             isOnline: () => sdk.isOnline(),
         };
     }
@@ -8359,12 +8898,11 @@ class SDKManager {
         await this.notificationService.triggerSync();
     }
     /**
-     * Get telemetry for a specific PEM
+     * Manually trigger a telemetry sync
      */
-    async getTelemetry(pemId) {
+    async syncTelemetry() {
         this.ensureInitialized();
-        const state = await this.telemetryService.getTelemetry(pemId);
-        return state.data;
+        return this.telemetryService.triggerSync();
     }
     /**
      * Check if the manager is initialized