@a-cube-io/ereceipts-js-sdk 2.0.8 → 2.1.0

package/dist/index.cjs.js

@@ -1415,6 +1415,15 @@ function from(input, scheduler) {
     return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
 
+function of() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    return from(args, scheduler);
+}
+
 function isValidDate(value) {
     return value instanceof Date && !isNaN(value);
 }
@@ -2126,7 +2135,7 @@ function formatDecimal(value, decimals = 2) {
     return num.toFixed(decimals);
 }
 
-const log$g = createPrefixedLogger('AUTH-SERVICE');
+const log$b = createPrefixedLogger('AUTH-SERVICE');
 class AuthenticationService {
     get user$() {
         return this.userSubject.asObservable();
@@ -2148,7 +2157,7 @@ class AuthenticationService {
     }
     async login(credentials) {
         this.authStateSubject.next('authenticating');
-        log$g.info('Login attempt', {
+        log$b.info('Login attempt', {
             authUrl: this.config.authUrl,
             email: credentials.email,
         });
@@ -2159,7 +2168,7 @@ class AuthenticationService {
             });
             const jwtPayload = parseJwt(response.data.token);
             const expiresAt = jwtPayload.exp * 1000;
-            log$g.info('Login successful', {
+            log$b.info('Login successful', {
                 authUrl: this.config.authUrl,
                 tokenPrefix: response.data.token.substring(0, 30) + '...',
                 expiresAt: new Date(expiresAt).toISOString(),
@@ -2188,21 +2197,21 @@ class AuthenticationService {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
             // No token - clear any stale user state
-            log$g.debug('getCurrentUser: No token in storage');
+            log$b.debug('getCurrentUser: No token in storage');
             if (this.userSubject.value) {
                 this.userSubject.next(null);
                 this.authStateSubject.next('idle');
             }
             return null;
         }
-        log$g.debug('getCurrentUser: Token found', {
+        log$b.debug('getCurrentUser: Token found', {
             tokenPrefix: token.substring(0, 30) + '...',
             tokenLength: token.length,
         });
         const jwtPayload = parseJwt(token);
         if (isTokenExpired(jwtPayload)) {
             // Token expired - clear everything
-            log$g.warn('getCurrentUser: Token expired');
+            log$b.warn('getCurrentUser: Token expired');
             await this.tokenStorage.clearTokens();
             this.userSubject.next(null);
             this.authStateSubject.next('idle');
@@ -2212,7 +2221,7 @@ class AuthenticationService {
         // Token is valid - return cached user if available
         const currentUser = this.userSubject.value;
         if (currentUser) {
-            log$g.debug('getCurrentUser: Returning cached user', {
+            log$b.debug('getCurrentUser: Returning cached user', {
                 email: currentUser.email,
                 roles: currentUser.roles,
             });
@@ -2235,12 +2244,12 @@ class AuthenticationService {
     async isAuthenticated() {
         const token = await this.tokenStorage.getAccessToken();
         if (!token) {
-            log$g.debug('isAuthenticated: No token in storage');
+            log$b.debug('isAuthenticated: No token in storage');
             return false;
         }
         const jwtPayload = parseJwt(token);
         const expired = isTokenExpired(jwtPayload);
-        log$g.debug('isAuthenticated: Token check', {
+        log$b.debug('isAuthenticated: Token check', {
             hasToken: true,
             expired,
             expiresAt: new Date(jwtPayload.exp * 1000).toISOString(),
@@ -2912,7 +2921,7 @@ class ACubeSDKError extends Error {
     }
 }
 
-const log$f = createPrefixedLogger('AUTH-STRATEGY');
+const log$a = createPrefixedLogger('AUTH-STRATEGY');
 class AuthStrategy {
     constructor(jwtHandler, mtlsHandler, userProvider, mtlsAdapter) {
         this.jwtHandler = jwtHandler;
@@ -2927,7 +2936,7 @@ class AuthStrategy {
         const platform = this.detectPlatform();
         const userRole = await this.getUserRole();
         const isReceiptEndpoint = this.isReceiptEndpoint(url);
-        log$f.debug('Determining auth config', {
+        log$a.debug('Determining auth config', {
             url,
             method,
             platform,
@@ -3058,7 +3067,7 @@ class JwtAuthHandler {
     }
 }
 
-const log$e = createPrefixedLogger('MTLS-HANDLER');
+const log$9 = createPrefixedLogger('MTLS-HANDLER');
 class MtlsAuthHandler {
     constructor(mtlsAdapter, certificatePort) {
         this.mtlsAdapter = mtlsAdapter;
@@ -3100,7 +3109,7 @@ class MtlsAuthHandler {
     async makeRequest(url, config, jwtToken) {
         const requestKey = this.generateRequestKey(url, config, jwtToken);
         if (this.pendingRequests.has(requestKey)) {
-            log$e.debug('Deduplicating concurrent request:', url);
+            log$9.debug('Deduplicating concurrent request:', url);
             return this.pendingRequests.get(requestKey);
         }
         const requestPromise = this.executeRequest(url, config, jwtToken, false);
@@ -3124,10 +3133,10 @@ class MtlsAuthHandler {
         };
         if (jwtToken) {
             headers['Authorization'] = `Bearer ${jwtToken}`;
-            log$e.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
+            log$9.debug('JWT token present:', jwtToken.substring(0, 20) + '...');
         }
         else {
-            log$e.warn('No JWT token provided for mTLS request');
+            log$9.warn('No JWT token provided for mTLS request');
         }
         const fullUrl = this.constructMtlsUrl(url);
         const mtlsConfig = {
@@ -3138,25 +3147,25 @@ class MtlsAuthHandler {
             timeout: config.timeout,
             responseType: config.responseType,
         };
-        log$e.debug('header-mtls', headers);
-        log$e.debug(`${config.method} ${fullUrl}`);
+        log$9.debug('header-mtls', headers);
+        log$9.debug(`${config.method} ${fullUrl}`);
         if (config.data) {
-            log$e.debug('Request body:', config.data);
+            log$9.debug('Request body:', config.data);
         }
         try {
             const response = await this.mtlsAdapter.request(mtlsConfig);
-            log$e.debug(`Response ${response.status} from ${fullUrl}`);
+            log$9.debug(`Response ${response.status} from ${fullUrl}`);
             if (response.data) {
-                log$e.debug('Response body:', response.data);
+                log$9.debug('Response body:', response.data);
             }
             return response.data;
         }
         catch (error) {
-            log$e.error(`Response error from ${fullUrl}:`, error);
+            log$9.error(`Response error from ${fullUrl}:`, error);
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 if (axiosError.response?.data) {
-                    log$e.error('Response body:', axiosError.response.data);
+                    log$9.error('Response body:', axiosError.response.data);
                 }
             }
             if (isRetryAttempt) {
@@ -3166,7 +3175,7 @@ class MtlsAuthHandler {
             if (!shouldRetry) {
                 throw error;
             }
-            log$e.debug('Request failed, reconfiguring certificate and retrying...');
+            log$9.debug('Request failed, reconfiguring certificate and retrying...');
             try {
                 await this.configureCertificate(certificate);
                 return await this.executeRequest(url, config, jwtToken, true);
@@ -3250,1923 +3259,27 @@ class MtlsAuthHandler {
             adapterAvailable: !!this.mtlsAdapter,
             certificatePortAvailable: !!this.certificatePort,
             isReady: false,
-            hasCertificate: false,
-            certificateInfo: null,
-            platformInfo: this.mtlsAdapter?.getPlatformInfo() || null,
-            pendingRequestsCount: this.pendingRequests.size,
-        };
-        if (this.certificatePort) {
-            try {
-                status.hasCertificate = await this.certificatePort.hasCertificate();
-                if (status.hasCertificate) {
-                    status.certificateInfo = await this.certificatePort.getCertificateInfo();
-                }
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-        status.isReady = await this.isMtlsReady();
-        return status;
-    }
-    clearPendingRequests() {
-        this.pendingRequests.clear();
-    }
-}
-
-const DEFAULT_QUEUE_CONFIG = {
-    maxRetries: 3,
-    retryDelay: 1000,
-    maxRetryDelay: 30000,
-    backoffMultiplier: 2,
-    maxQueueSize: 1000,
-    batchSize: 10,
-    syncInterval: 30000,
-};
-
-class OperationQueue {
-    constructor(storage, config = DEFAULT_QUEUE_CONFIG, events = {}) {
-        this.storage = storage;
-        this.config = config;
-        this.events = events;
-        this.queue = [];
-        this.processing = false;
-        this.config = { ...DEFAULT_QUEUE_CONFIG, ...config };
-        this.loadQueue();
-        if (this.config.syncInterval > 0) {
-            this.startAutoSync();
-        }
-    }
-    async addOperation(type, resource, endpoint, method, data, priority = 1) {
-        if (this.queue.length >= this.config.maxQueueSize) {
-            const lowPriorityIndex = this.queue.findIndex((op) => op.priority === 1);
-            if (lowPriorityIndex !== -1) {
-                this.queue.splice(lowPriorityIndex, 1);
-            }
-            else {
-                throw new Error('Queue is full');
-            }
-        }
-        const operation = {
-            id: this.generateId(),
-            type,
-            resource,
-            endpoint,
-            method,
-            data,
-            status: 'pending',
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-            retryCount: 0,
-            maxRetries: this.config.maxRetries,
-            priority,
-        };
-        const insertIndex = this.queue.findIndex((op) => op.priority < priority);
-        if (insertIndex === -1) {
-            this.queue.push(operation);
-        }
-        else {
-            this.queue.splice(insertIndex, 0, operation);
-        }
-        await this.saveQueue();
-        this.events.onOperationAdded?.(operation);
-        return operation.id;
-    }
-    getPendingOperations() {
-        return this.queue.filter((op) => op.status === 'pending' || op.status === 'failed');
-    }
-    getOperation(id) {
-        return this.queue.find((op) => op.id === id);
-    }
-    async removeOperation(id) {
-        const index = this.queue.findIndex((op) => op.id === id);
-        if (index === -1)
-            return false;
-        this.queue.splice(index, 1);
-        await this.saveQueue();
-        return true;
-    }
-    async updateOperation(id, updates) {
-        const operation = this.queue.find((op) => op.id === id);
-        if (!operation)
-            return false;
-        Object.assign(operation, { ...updates, updatedAt: Date.now() });
-        await this.saveQueue();
-        return true;
-    }
-    getStats() {
-        return {
-            total: this.queue.length,
-            pending: this.queue.filter((op) => op.status === 'pending').length,
-            processing: this.queue.filter((op) => op.status === 'processing').length,
-            completed: this.queue.filter((op) => op.status === 'completed').length,
-            failed: this.queue.filter((op) => op.status === 'failed').length,
-        };
-    }
-    async clearQueue() {
-        this.queue = [];
-        await this.saveQueue();
-    }
-    async clearCompleted() {
-        this.queue = this.queue.filter((op) => op.status !== 'completed');
-        await this.saveQueue();
-    }
-    async clearFailed() {
-        this.queue = this.queue.filter((op) => op.status !== 'failed');
-        await this.saveQueue();
-    }
-    async retryFailed() {
-        for (const operation of this.queue.filter((op) => op.status === 'failed')) {
-            if (operation.retryCount < operation.maxRetries) {
-                operation.status = 'pending';
-                operation.retryCount++;
-                operation.updatedAt = Date.now();
-                delete operation.error;
-            }
-        }
-        await this.saveQueue();
-    }
-    getNextBatch() {
-        return this.queue
-            .filter((op) => op.status === 'pending')
-            .sort((a, b) => b.priority - a.priority || a.createdAt - b.createdAt)
-            .slice(0, this.config.batchSize);
-    }
-    isEmpty() {
-        return this.getPendingOperations().length === 0;
-    }
-    startAutoSync() {
-        if (this.syncIntervalId)
-            return;
-        this.syncIntervalId = setInterval(() => {
-            if (!this.isEmpty() && !this.processing) {
-                this.events.onQueueEmpty?.();
-            }
-        }, this.config.syncInterval);
-    }
-    stopAutoSync() {
-        if (this.syncIntervalId) {
-            clearInterval(this.syncIntervalId);
-            this.syncIntervalId = undefined;
-        }
-    }
-    setProcessing(value) {
-        this.processing = value;
-    }
-    isCurrentlyProcessing() {
-        return this.processing;
-    }
-    async loadQueue() {
-        try {
-            const queueData = await this.storage.get(OperationQueue.QUEUE_KEY);
-            if (queueData) {
-                this.queue = JSON.parse(queueData);
-                this.queue.forEach((op) => {
-                    if (op.status === 'processing') {
-                        op.status = 'pending';
-                    }
-                });
-            }
-        }
-        catch {
-            this.queue = [];
-        }
-    }
-    async saveQueue() {
-        try {
-            await this.storage.set(OperationQueue.QUEUE_KEY, JSON.stringify(this.queue));
-        }
-        catch (error) {
-            this.events.onError?.(new Error(`Failed to save queue: ${error}`));
-        }
-    }
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    destroy() {
-        this.stopAutoSync();
-    }
-}
-OperationQueue.QUEUE_KEY = 'acube_operation_queue';
-
-class SyncManager {
-    constructor(queue, httpPort, networkMonitor, config, events = {}) {
-        this.queue = queue;
-        this.httpPort = httpPort;
-        this.networkMonitor = networkMonitor;
-        this.config = config;
-        this.events = events;
-        this.isOnline = true;
-        this.destroy$ = new Subject();
-        this.setupNetworkMonitoring();
-    }
-    setupNetworkMonitoring() {
-        // Subscribe to online$ to track current state
-        this.networkSubscription = this.networkMonitor.online$
-            .pipe(startWith(true), // Assume online initially
-        pairwise(), filter(([wasOnline, isNowOnline]) => !wasOnline && isNowOnline), takeUntil(this.destroy$))
-            .subscribe(() => {
-            // Offline → Online transition detected
-            this.syncPendingOperations();
-        });
-        // Track current online state
-        this.networkMonitor.online$.pipe(takeUntil(this.destroy$)).subscribe((online) => {
-            this.isOnline = online;
-        });
-    }
-    async syncPendingOperations() {
-        if (!this.isOnline) {
-            throw new Error('Cannot sync while offline');
-        }
-        if (this.queue.isCurrentlyProcessing()) {
-            throw new Error('Sync already in progress');
-        }
-        this.queue.setProcessing(true);
-        try {
-            const results = [];
-            let successCount = 0;
-            let failureCount = 0;
-            while (!this.queue.isEmpty()) {
-                const batch = this.queue.getNextBatch();
-                if (batch.length === 0)
-                    break;
-                const batchPromises = batch.map((operation) => this.processOperation(operation));
-                const batchResults = await Promise.allSettled(batchPromises);
-                batchResults.forEach((result, index) => {
-                    const operation = batch[index];
-                    if (!operation)
-                        return;
-                    if (result.status === 'fulfilled') {
-                        const syncResult = result.value;
-                        results.push(syncResult);
-                        if (syncResult.success) {
-                            successCount++;
-                            this.events.onOperationCompleted?.(syncResult);
-                        }
-                        else {
-                            failureCount++;
-                            this.events.onOperationFailed?.(syncResult);
-                        }
-                    }
-                    else {
-                        const syncResult = {
-                            operation,
-                            success: false,
-                            error: result.reason?.message || 'Unknown error',
-                        };
-                        results.push(syncResult);
-                        failureCount++;
-                        this.events.onOperationFailed?.(syncResult);
-                        this.queue.updateOperation(operation.id, {
-                            status: 'failed',
-                            error: syncResult.error,
-                        });
-                    }
-                });
-                if (!this.queue.isEmpty()) {
-                    await this.delay(500);
-                }
-            }
-            const batchResult = {
-                totalOperations: results.length,
-                successCount,
-                failureCount,
-                results,
-            };
-            this.events.onBatchSyncCompleted?.(batchResult);
-            if (this.queue.isEmpty()) {
-                this.events.onQueueEmpty?.();
-            }
-            return batchResult;
-        }
-        finally {
-            this.queue.setProcessing(false);
-        }
-    }
-    async processOperation(operation) {
-        await this.queue.updateOperation(operation.id, { status: 'processing' });
-        try {
-            const response = await this.executeOperation(operation);
-            await this.queue.updateOperation(operation.id, { status: 'completed' });
-            return { operation, success: true, response };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            if (operation.retryCount < operation.maxRetries && this.isRetryableError(error)) {
-                const delay = this.calculateRetryDelay(operation.retryCount);
-                await this.queue.updateOperation(operation.id, {
-                    status: 'pending',
-                    retryCount: operation.retryCount + 1,
-                    error: errorMessage,
-                });
-                setTimeout(() => {
-                    if (this.isOnline && !this.queue.isCurrentlyProcessing()) {
-                        this.syncPendingOperations();
-                    }
-                }, delay);
-                return { operation, success: false, error: `Retrying: ${errorMessage}` };
-            }
-            else {
-                await this.queue.updateOperation(operation.id, {
-                    status: 'failed',
-                    error: errorMessage,
-                });
-                return { operation, success: false, error: errorMessage };
-            }
-        }
-    }
-    async executeOperation(operation) {
-        const { method, endpoint, data, headers } = operation;
-        const config = headers ? { headers } : undefined;
-        switch (method) {
-            case 'GET':
-                return (await this.httpPort.get(endpoint, config)).data;
-            case 'POST':
-                return (await this.httpPort.post(endpoint, data, config)).data;
-            case 'PUT':
-                return (await this.httpPort.put(endpoint, data, config)).data;
-            case 'PATCH':
-                return (await this.httpPort.patch(endpoint, data, config)).data;
-            case 'DELETE':
-                return (await this.httpPort.delete(endpoint, config)).data;
-            default:
-                throw new Error(`Unsupported HTTP method: ${method}`);
-        }
-    }
-    isRetryableError(error) {
-        const errorObj = error;
-        if (errorObj.code === 'NETWORK_ERROR')
-            return true;
-        if (errorObj.statusCode && errorObj.statusCode >= 500)
-            return true;
-        if (errorObj.statusCode === 429)
-            return true;
-        const errorMessage = error?.message;
-        if (errorObj.code === 'ECONNABORTED' || errorMessage?.includes('timeout'))
-            return true;
-        return false;
-    }
-    calculateRetryDelay(retryCount) {
-        const delay = this.config.retryDelay * Math.pow(this.config.backoffMultiplier, retryCount);
-        return Math.min(delay, this.config.maxRetryDelay);
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    isCurrentlyOnline() {
-        return this.isOnline;
-    }
-    async triggerSync() {
-        if (!this.isOnline)
-            return null;
-        if (this.queue.isEmpty()) {
-            return { totalOperations: 0, successCount: 0, failureCount: 0, results: [] };
-        }
-        return await this.syncPendingOperations();
-    }
-    getSyncStatus() {
-        return {
-            isOnline: this.isOnline,
-            isProcessing: this.queue.isCurrentlyProcessing(),
-            queueStats: this.queue.getStats(),
-        };
-    }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-        this.networkSubscription?.unsubscribe();
-    }
-}
-
-class OfflineManager {
-    get queue$() {
-        return this.queueSubject.asObservable();
-    }
-    get syncStatus$() {
-        return this.syncStatusSubject.asObservable();
-    }
-    constructor(storage, httpPort, networkMonitor, config = {}, events = {}, _cache) {
-        this.queueSubject = new BehaviorSubject([]);
-        this.syncStatusSubject = new BehaviorSubject({
-            isOnline: true,
-            isProcessing: false,
-            queueStats: { total: 0, pending: 0, processing: 0, completed: 0, failed: 0 },
-        });
-        this.destroy$ = new Subject();
-        const finalConfig = { ...DEFAULT_QUEUE_CONFIG, ...config };
-        const wrappedEvents = {
-            ...events,
-            onOperationAdded: (op) => {
-                this.updateQueueState();
-                events.onOperationAdded?.(op);
-            },
-            onOperationCompleted: (result) => {
-                this.updateQueueState();
-                events.onOperationCompleted?.(result);
-            },
-            onOperationFailed: (result) => {
-                this.updateQueueState();
-                events.onOperationFailed?.(result);
-            },
-            onBatchSyncCompleted: (result) => {
-                this.updateQueueState();
-                events.onBatchSyncCompleted?.(result);
-            },
-        };
-        this.queue = new OperationQueue(storage, finalConfig, wrappedEvents);
-        this.syncManager = new SyncManager(this.queue, httpPort, networkMonitor, finalConfig, wrappedEvents);
-        this.updateQueueState();
-    }
-    updateQueueState() {
-        this.queueSubject.next(this.queue.getPendingOperations());
-        this.syncStatusSubject.next(this.syncManager.getSyncStatus());
-    }
-    async queueOperation(type, resource, endpoint, method, data, priority = 1) {
-        const id = await this.queue.addOperation(type, resource, endpoint, method, data, priority);
-        this.updateQueueState();
-        return id;
-    }
-    async queueReceiptCreation(receiptData, priority = 2) {
-        return await this.queueOperation('CREATE', 'receipt', '/mf1/receipts', 'POST', receiptData, priority);
-    }
-    async queueReceiptVoid(voidData, priority = 3) {
-        return await this.queueOperation('DELETE', 'receipt', '/mf1/receipts', 'DELETE', voidData, priority);
-    }
-    async queueReceiptReturn(returnData, priority = 3) {
-        return await this.queueOperation('CREATE', 'receipt', '/mf1/receipts/return', 'POST', returnData, priority);
-    }
-    async queueCashierCreation(cashierData, priority = 1) {
-        return await this.queueOperation('CREATE', 'cashier', '/mf1/cashiers', 'POST', cashierData, priority);
-    }
-    isOnline() {
-        return this.syncManager.isCurrentlyOnline();
-    }
-    getStatus() {
-        return this.syncManager.getSyncStatus();
-    }
-    getPendingCount() {
-        return this.queue.getPendingOperations().length;
-    }
-    isEmpty() {
-        return this.queue.isEmpty();
-    }
-    async sync() {
-        const result = await this.syncManager.triggerSync();
-        this.updateQueueState();
-        return result;
-    }
-    async retryFailed() {
-        await this.queue.retryFailed();
-        this.updateQueueState();
-        if (this.isOnline()) {
-            await this.sync();
-        }
-    }
-    async clearCompleted() {
-        await this.queue.clearCompleted();
-        this.updateQueueState();
-    }
-    async clearFailed() {
-        await this.queue.clearFailed();
-        this.updateQueueState();
-    }
-    async clearAll() {
-        await this.queue.clearQueue();
-        this.updateQueueState();
-    }
-    getOperation(id) {
-        return this.queue.getOperation(id);
-    }
-    async removeOperation(id) {
-        const result = await this.queue.removeOperation(id);
-        this.updateQueueState();
-        return result;
-    }
-    getQueueStats() {
-        return this.queue.getStats();
-    }
-    startAutoSync() {
-        this.queue.startAutoSync();
-    }
-    stopAutoSync() {
-        this.queue.stopAutoSync();
-    }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-        this.queue.destroy();
-        this.syncManager.destroy();
-    }
-}
-
-class CompressionAdapter {
-    compress(data, threshold = 1024) {
-        const originalSize = data.length * 2;
-        if (originalSize < threshold) {
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-        try {
-            const compressed = this.compressString(data);
-            const compressedSize = compressed.length * 2;
-            if (compressedSize < originalSize) {
-                return {
-                    data: compressed,
-                    compressed: true,
-                    originalSize,
-                    compressedSize,
-                };
-            }
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-        catch {
-            return {
-                data,
-                compressed: false,
-                originalSize,
-                compressedSize: originalSize,
-            };
-        }
-    }
-    decompress(data, compressed) {
-        if (!compressed) {
-            return { data, wasCompressed: false };
-        }
-        try {
-            const decompressed = this.decompressString(data);
-            return { data: decompressed, wasCompressed: true };
-        }
-        catch {
-            return { data, wasCompressed: false };
-        }
-    }
-    estimateSavings(data) {
-        const repeated = data.match(/(.)\1{3,}/g);
-        if (!repeated)
-            return 0;
-        let savings = 0;
-        for (const match of repeated) {
-            const originalBytes = match.length * 2;
-            const compressedBytes = 6;
-            if (originalBytes > compressedBytes) {
-                savings += originalBytes - compressedBytes;
-            }
-        }
-        return Math.min(savings, data.length * 2 * 0.5);
-    }
-    compressString(input) {
-        let compressed = '';
-        let i = 0;
-        while (i < input.length) {
-            let count = 1;
-            const char = input[i];
-            while (i + count < input.length && input[i + count] === char && count < 255) {
-                count++;
-            }
-            if (count > 3) {
-                compressed += `~${count}${char}`;
-            }
-            else {
-                for (let j = 0; j < count; j++) {
-                    compressed += char;
-                }
-            }
-            i += count;
-        }
-        return `COMP:${btoa(compressed)}`;
-    }
-    decompressString(input) {
-        if (!input.startsWith('COMP:')) {
-            return input;
-        }
-        const encodedData = input.substring(5);
-        if (!encodedData) {
-            return input;
-        }
-        const compressed = atob(encodedData);
-        let decompressed = '';
-        let i = 0;
-        while (i < compressed.length) {
-            if (compressed[i] === '~' && i + 2 < compressed.length) {
-                let countStr = '';
-                i++;
-                while (i < compressed.length) {
-                    const char = compressed[i];
-                    if (char && /\d/.test(char)) {
-                        countStr += char;
-                        i++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                if (countStr && i < compressed.length) {
-                    const count = parseInt(countStr, 10);
-                    const char = compressed[i];
-                    for (let j = 0; j < count; j++) {
-                        decompressed += char;
-                    }
-                    i++;
-                }
-            }
-            else {
-                decompressed += compressed[i];
-                i++;
-            }
-        }
-        return decompressed;
-    }
-}
-function compressData(data, threshold = 1024) {
-    return new CompressionAdapter().compress(data, threshold);
-}
-function decompressData(data, compressed) {
-    return new CompressionAdapter().decompress(data, compressed);
-}
-
-const log$d = createPrefixedLogger('CACHE-RN');
-/**
- * React Native cache adapter using SQLite (Expo or react-native-sqlite-storage)
- * Cache never expires - data persists until explicitly invalidated
- */
-class ReactNativeCacheAdapter {
-    constructor(options = {}) {
-        this.db = null;
-        this.initPromise = null;
-        this.isExpo = false;
-        this.hasCompressedColumn = false;
-        this.options = {
-            maxSize: 50 * 1024 * 1024, // 50MB
-            maxEntries: 10000,
-            compression: false,
-            compressionThreshold: 1024,
-            ...options,
-        };
-        this.initPromise = this.initialize();
-    }
-    normalizeResults(results) {
-        if (this.isExpo) {
-            const expoResults = results;
-            if (Array.isArray(expoResults)) {
-                return expoResults;
-            }
-            return expoResults.results || [];
-        }
-        else {
-            const rnResults = results;
-            const rows = rnResults.rows;
-            if (!rows || rows.length === 0)
-                return [];
-            const normalizedRows = [];
-            for (let i = 0; i < rows.length; i++) {
-                normalizedRows.push(rows.item(i));
-            }
-            return normalizedRows;
-        }
-    }
-    async initialize() {
-        if (this.db)
-            return;
-        try {
-            // Try Expo SQLite first
-            const ExpoSQLite = require('expo-sqlite');
-            this.db = await ExpoSQLite.openDatabaseAsync(ReactNativeCacheAdapter.DB_NAME);
-            this.isExpo = true;
-            await this.createTables();
-        }
-        catch (expoError) {
-            try {
-                // Fallback to react-native-sqlite-storage
-                const SQLite = require('react-native-sqlite-storage');
-                this.db = await new Promise((resolve, reject) => {
-                    SQLite.openDatabase({
-                        name: ReactNativeCacheAdapter.DB_NAME,
-                        location: 'default',
-                    }, resolve, reject);
-                });
-                this.isExpo = false;
-                await this.createTables();
-            }
-            catch (rnError) {
-                throw new Error(`Failed to initialize SQLite: Expo error: ${expoError}, RN error: ${rnError}`);
-            }
-        }
-    }
-    async createTables() {
-        // Create table with simplified schema (no TTL)
-        const createTableSQL = `
-      CREATE TABLE IF NOT EXISTS ${ReactNativeCacheAdapter.TABLE_NAME} (
-        cache_key TEXT PRIMARY KEY,
-        data TEXT NOT NULL,
-        timestamp INTEGER NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_timestamp ON ${ReactNativeCacheAdapter.TABLE_NAME}(timestamp);
-    `;
-        await this.executeSql(createTableSQL);
-        // Then, run migrations to add new columns if they don't exist
-        await this.runMigrations();
-    }
-    async runMigrations() {
-        log$d.debug('Running database migrations...');
-        try {
-            // Check if compressed column exists
-            this.hasCompressedColumn = await this.checkColumnExists('compressed');
-            if (!this.hasCompressedColumn) {
-                log$d.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$d.debug('Successfully added compressed column');
-            }
-            else {
-                log$d.debug('Compressed column already exists');
-            }
-            log$d.debug('Database migrations completed', {
-                hasCompressedColumn: this.hasCompressedColumn,
-            });
-        }
-        catch (error) {
-            log$d.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
-        }
-    }
-    async checkColumnExists(columnName) {
-        try {
-            const pragmaSQL = `PRAGMA table_info(${ReactNativeCacheAdapter.TABLE_NAME})`;
-            const results = await this.executeSql(pragmaSQL);
-            const columns = this.normalizeResults(results);
-            log$d.debug('Table columns found', { columns: columns.map((c) => c.name) });
-            return columns.some((column) => column.name === columnName);
-        }
-        catch (error) {
-            log$d.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$d.debug('Executing get query', { sql, key });
-        const results = await this.executeSql(sql, [key]);
-        log$d.debug('Get query results', { key, hasResults: !!results });
-        // Normalize results from different SQLite implementations
-        const rows = this.normalizeResults(results);
-        if (!rows || rows.length === 0) {
-            return null;
-        }
-        const row = rows[0];
-        if (!row) {
-            return null;
-        }
-        const isCompressed = this.hasCompressedColumn ? !!row.compressed : false;
-        const rawData = isCompressed ? decompressData(row.data, true).data : row.data;
-        return {
-            data: JSON.parse(rawData),
-            timestamp: row.timestamp,
-            compressed: isCompressed,
-        };
-    }
-    async set(key, data) {
-        const item = {
-            data,
-            timestamp: Date.now(),
-        };
-        log$d.debug('Setting cache item', { key });
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        await this.ensureInitialized();
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-            log$d.debug('Compression result', {
-                key,
-                originalSize: compressionResult.originalSize,
-                compressedSize: compressionResult.compressedSize,
-                compressed: isCompressed,
-                savings: compressionResult.originalSize - compressionResult.compressedSize,
-            });
-        }
-        log$d.debug('Setting item with metadata', {
-            key,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
-            hasCompressedColumn: this.hasCompressedColumn,
-        });
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            // Fallback for databases without compressed column
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        log$d.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$d.debug('Batch setting items', { count: items.length });
-        if (this.isExpo) {
-            await this.db.withTransactionAsync(async () => {
-                for (const [key, item] of items) {
-                    await this.setBatchItem(key, item);
-                }
-            });
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this.db.transaction((tx) => {
-                    const promises = items.map(([key, item]) => this.setBatchItemRN(tx, key, item));
-                    Promise.all(promises)
-                        .then(() => resolve())
-                        .catch(reject);
-                }, reject, () => resolve());
-            });
-        }
-        log$d.debug('Batch operation completed', { count: items.length });
-    }
-    async setBatchItem(key, item) {
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-        }
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        await this.db.runAsync(sql, params);
-    }
-    async setBatchItemRN(tx, key, item) {
-        // Handle compression if enabled and compressed column is available
-        const serializedData = JSON.stringify(item.data);
-        let finalData = serializedData;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold && this.hasCompressedColumn) {
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            finalData = compressionResult.data;
-            isCompressed = compressionResult.compressed;
-        }
-        // Build SQL and parameters based on available columns
-        let sql;
-        let params;
-        if (this.hasCompressedColumn) {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp, compressed)
-        VALUES (?, ?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp, isCompressed ? 1 : 0];
-        }
-        else {
-            sql = `
-        INSERT OR REPLACE INTO ${ReactNativeCacheAdapter.TABLE_NAME}
-        (cache_key, data, timestamp)
-        VALUES (?, ?, ?)
-      `;
-            params = [key, finalData, item.timestamp];
-        }
-        return new Promise((resolve, reject) => {
-            tx.executeSql(sql, params, () => resolve(), (_, error) => {
-                reject(error);
-                return false;
-            });
-        });
-    }
-    async invalidate(pattern) {
-        await this.ensureInitialized();
-        const keys = await this.getKeys(pattern);
-        if (keys.length === 0)
-            return;
-        const placeholders = keys.map(() => '?').join(',');
-        const sql = `DELETE FROM ${ReactNativeCacheAdapter.TABLE_NAME} WHERE cache_key IN (${placeholders})`;
-        await this.executeSql(sql, keys);
-    }
-    async clear() {
-        await this.ensureInitialized();
-        const sql = `DELETE FROM ${ReactNativeCacheAdapter.TABLE_NAME}`;
-        await this.executeSql(sql);
-    }
-    async getSize() {
-        await this.ensureInitialized();
-        const sql = `
-      SELECT
-        COUNT(*) as entries,
-        SUM(LENGTH(data)) as bytes
-      FROM ${ReactNativeCacheAdapter.TABLE_NAME}
-    `;
-        const results = await this.executeSql(sql);
-        const rows = this.normalizeResults(results);
-        const row = rows[0] || { entries: 0, bytes: 0 };
-        return {
-            entries: row.entries || 0,
-            bytes: (row.bytes || 0) * 2,
-            lastCleanup: Date.now(),
-        };
-    }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        await this.ensureInitialized();
-        let sql = `SELECT cache_key FROM ${ReactNativeCacheAdapter.TABLE_NAME}`;
-        const params = [];
-        if (pattern) {
-            // Simple pattern matching with LIKE
-            const likePattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
-            sql += ' WHERE cache_key LIKE ?';
-            params.push(likePattern);
-        }
-        const results = await this.executeSql(sql, params);
-        const keys = [];
-        const rows = this.normalizeResults(results);
-        for (const row of rows) {
-            keys.push(row.cache_key);
-        }
-        return keys;
-    }
-    async executeSql(sql, params = []) {
-        if (this.isExpo) {
-            const expoDB = this.db;
-            if (sql.toLowerCase().includes('select') || sql.toLowerCase().includes('pragma')) {
-                const result = await expoDB.getAllAsync(sql, params);
-                return Array.isArray(result) ? { results: result } : result;
-            }
-            else {
-                return await expoDB.runAsync(sql, params);
-            }
-        }
-        else {
-            // react-native-sqlite-storage
-            return new Promise((resolve, reject) => {
-                this.db.transaction((tx) => {
-                    tx.executeSql(sql, params, (_, results) => resolve(results), (_, error) => {
-                        reject(error);
-                        return false;
-                    });
-                });
-            });
-        }
-    }
-    async ensureInitialized() {
-        if (!this.initPromise) {
-            this.initPromise = this.initialize();
-        }
-        await this.initPromise;
-    }
-}
-ReactNativeCacheAdapter.DB_NAME = 'acube_cache.db';
-ReactNativeCacheAdapter.TABLE_NAME = 'cache_entries';
-/**
- * Memory-based fallback cache adapter for environments without SQLite
- * Cache never expires - data persists until explicitly invalidated
- */
-class MemoryCacheAdapter {
-    constructor(options = {}) {
-        this.cache = new Map();
-        this.totalBytes = 0;
-        this.options = {
-            maxEntries: 1000,
-            ...options,
-        };
-    }
-    calculateItemSize(key, item) {
-        // Calculate rough size estimation for memory usage
-        const keySize = key.length * 2; // UTF-16 estimation
-        const itemSize = JSON.stringify(item).length * 2; // UTF-16 estimation
-        return keySize + itemSize;
-    }
-    async get(key) {
-        log$d.debug('Getting cache item', { key });
-        const item = this.cache.get(key);
-        if (!item) {
-            log$d.debug('Cache miss', { key });
-            return null;
-        }
-        // Handle decompression if needed
-        const isCompressed = !!item.compressed;
-        let finalData = item.data;
-        if (isCompressed) {
-            const decompressed = decompressData(item.data, true);
-            finalData = JSON.parse(decompressed.data);
-        }
-        log$d.debug('Cache hit', { key, compressed: isCompressed });
-        return {
-            ...item,
-            data: finalData,
-            compressed: isCompressed,
-        };
-    }
-    async set(key, data) {
-        log$d.debug('Setting cache item', { key });
-        // Handle compression if enabled
-        let finalData = data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-                log$d.debug('Compression result', {
-                    key,
-                    originalSize: compressionResult.originalSize,
-                    compressedSize: compressionResult.compressedSize,
-                    savings: compressionResult.originalSize - compressionResult.compressedSize,
-                });
-            }
-        }
-        const item = {
-            data: finalData,
-            timestamp: Date.now(),
-            compressed: isCompressed,
-        };
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        // Calculate size of new item
-        const newItemSize = this.calculateItemSize(key, item);
-        // If item already exists, subtract old size
-        if (this.cache.has(key)) {
-            const oldItem = this.cache.get(key);
-            const oldItemSize = this.calculateItemSize(key, oldItem);
-            this.totalBytes -= oldItemSize;
-        }
-        // Enforce max entries limit
-        if (this.cache.size >= (this.options.maxEntries || 1000) && !this.cache.has(key)) {
-            const oldestKey = this.cache.keys().next().value;
-            if (oldestKey) {
-                const oldestItem = this.cache.get(oldestKey);
-                const oldestItemSize = this.calculateItemSize(oldestKey, oldestItem);
-                this.totalBytes -= oldestItemSize;
-                this.cache.delete(oldestKey);
-                log$d.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$d.debug('Updated cache size', {
-            entries: this.cache.size,
-            totalBytes: this.totalBytes,
-            newItemSize,
-        });
-    }
-    async setBatch(items) {
-        if (items.length === 0)
-            return;
-        log$d.debug('Batch setting items', { count: items.length });
-        let totalNewBytes = 0;
-        let totalOldBytes = 0;
-        const itemsToRemove = [];
-        // First pass: calculate size changes and identify capacity issues
-        for (const [key, item] of items) {
-            const newItemSize = this.calculateItemSize(key, item);
-            totalNewBytes += newItemSize;
-            // If item already exists, track old size for removal
-            if (this.cache.has(key)) {
-                const oldItem = this.cache.get(key);
-                const oldItemSize = this.calculateItemSize(key, oldItem);
-                totalOldBytes += oldItemSize;
-            }
-        }
-        // Handle capacity limits - remove oldest items if needed
-        const projectedEntries = this.cache.size + items.filter(([key]) => !this.cache.has(key)).length;
-        const maxEntries = this.options.maxEntries || 1000;
-        if (projectedEntries > maxEntries) {
-            const entriesToRemove = projectedEntries - maxEntries;
-            const oldestKeys = Array.from(this.cache.keys()).slice(0, entriesToRemove);
-            for (const oldKey of oldestKeys) {
-                const oldItem = this.cache.get(oldKey);
-                const oldItemSize = this.calculateItemSize(oldKey, oldItem);
-                this.totalBytes -= oldItemSize;
-                this.cache.delete(oldKey);
-                itemsToRemove.push(oldKey);
-            }
-            if (itemsToRemove.length > 0) {
-                log$d.debug('Removed items for batch capacity', {
-                    removedCount: itemsToRemove.length,
-                    removedKeys: itemsToRemove,
-                });
-            }
-        }
-        // Update total bytes accounting
-        this.totalBytes = this.totalBytes - totalOldBytes + totalNewBytes;
-        // Second pass: set all items
-        for (const [key, item] of items) {
-            this.cache.set(key, item);
-        }
-        log$d.debug('Batch operation completed', {
-            count: items.length,
-            totalBytes: this.totalBytes,
-            entries: this.cache.size,
-            bytesAdded: totalNewBytes - totalOldBytes,
-        });
-    }
-    async invalidate(pattern) {
-        const regex = this.patternToRegex(pattern);
-        let removed = 0;
-        let bytesFreed = 0;
-        for (const key of this.cache.keys()) {
-            if (regex.test(key)) {
-                const item = this.cache.get(key);
-                const itemSize = this.calculateItemSize(key, item);
-                this.cache.delete(key);
-                this.totalBytes -= itemSize;
-                bytesFreed += itemSize;
-                removed++;
-            }
-        }
-        if (removed > 0) {
-            log$d.debug('Invalidation completed', {
-                pattern,
-                entriesRemoved: removed,
-                bytesFreed,
-                remainingEntries: this.cache.size,
-                remainingBytes: this.totalBytes,
-            });
-        }
-    }
-    async clear() {
-        this.cache.clear();
-        this.totalBytes = 0;
-        log$d.debug('Cache cleared', { entries: 0, bytes: 0 });
-    }
-    async getSize() {
-        return {
-            entries: this.cache.size,
-            bytes: this.totalBytes,
-            lastCleanup: Date.now(),
-        };
-    }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        const keys = Array.from(this.cache.keys());
-        if (!pattern)
-            return keys;
-        const regex = this.patternToRegex(pattern);
-        return keys.filter((key) => regex.test(key));
-    }
-    patternToRegex(pattern) {
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        const regexPattern = escaped.replace(/\\\*/g, '.*').replace(/\\\?/g, '.');
-        return new RegExp(`^${regexPattern}$`);
-    }
-}
-
-const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-    return (idbProxyableTypes ||
-        (idbProxyableTypes = [
-            IDBDatabase,
-            IDBObjectStore,
-            IDBIndex,
-            IDBCursor,
-            IDBTransaction,
-        ]));
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-    return (cursorAdvanceMethods ||
-        (cursorAdvanceMethods = [
-            IDBCursor.prototype.advance,
-            IDBCursor.prototype.continue,
-            IDBCursor.prototype.continuePrimaryKey,
-        ]));
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-    const promise = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            request.removeEventListener('success', success);
-            request.removeEventListener('error', error);
-        };
-        const success = () => {
-            resolve(wrap(request.result));
-            unlisten();
-        };
-        const error = () => {
-            reject(request.error);
-            unlisten();
-        };
-        request.addEventListener('success', success);
-        request.addEventListener('error', error);
-    });
-    // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
-    // is because we create many promises from a single IDBRequest.
-    reverseTransformCache.set(promise, request);
-    return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-    // Early bail if we've already created a done promise for this transaction.
-    if (transactionDoneMap.has(tx))
-        return;
-    const done = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            tx.removeEventListener('complete', complete);
-            tx.removeEventListener('error', error);
-            tx.removeEventListener('abort', error);
-        };
-        const complete = () => {
-            resolve();
-            unlisten();
-        };
-        const error = () => {
-            reject(tx.error || new DOMException('AbortError', 'AbortError'));
-            unlisten();
-        };
-        tx.addEventListener('complete', complete);
-        tx.addEventListener('error', error);
-        tx.addEventListener('abort', error);
-    });
-    // Cache it for later retrieval.
-    transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-    get(target, prop, receiver) {
-        if (target instanceof IDBTransaction) {
-            // Special handling for transaction.done.
-            if (prop === 'done')
-                return transactionDoneMap.get(target);
-            // Make tx.store return the only store in the transaction, or undefined if there are many.
-            if (prop === 'store') {
-                return receiver.objectStoreNames[1]
-                    ? undefined
-                    : receiver.objectStore(receiver.objectStoreNames[0]);
-            }
-        }
-        // Else transform whatever we get back.
-        return wrap(target[prop]);
-    },
-    set(target, prop, value) {
-        target[prop] = value;
-        return true;
-    },
-    has(target, prop) {
-        if (target instanceof IDBTransaction &&
-            (prop === 'done' || prop === 'store')) {
-            return true;
-        }
-        return prop in target;
-    },
-};
-function replaceTraps(callback) {
-    idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-    // Due to expected object equality (which is enforced by the caching in `wrap`), we
-    // only create one new func per func.
-    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-    // with real promises, so each advance methods returns a new promise for the cursor object, or
-    // undefined if the end of the cursor has been reached.
-    if (getCursorAdvanceMethods().includes(func)) {
-        return function (...args) {
-            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-            // the original object.
-            func.apply(unwrap(this), args);
-            return wrap(this.request);
-        };
-    }
-    return function (...args) {
-        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-        // the original object.
-        return wrap(func.apply(unwrap(this), args));
-    };
-}
-function transformCachableValue(value) {
-    if (typeof value === 'function')
-        return wrapFunction(value);
-    // This doesn't return, it just creates a 'done' promise for the transaction,
-    // which is later returned for transaction.done (see idbObjectHandler).
-    if (value instanceof IDBTransaction)
-        cacheDonePromiseForTransaction(value);
-    if (instanceOfAny(value, getIdbProxyableTypes()))
-        return new Proxy(value, idbProxyTraps);
-    // Return the same value back if we're not going to transform it.
-    return value;
-}
-function wrap(value) {
-    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-    if (value instanceof IDBRequest)
-        return promisifyRequest(value);
-    // If we've already transformed this value before, reuse the transformed value.
-    // This is faster, but it also provides object equality.
-    if (transformCache.has(value))
-        return transformCache.get(value);
-    const newValue = transformCachableValue(value);
-    // Not all types are transformed.
-    // These may be primitive types, so they can't be WeakMap keys.
-    if (newValue !== value) {
-        transformCache.set(value, newValue);
-        reverseTransformCache.set(newValue, value);
-    }
-    return newValue;
-}
-const unwrap = (value) => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-    const request = indexedDB.open(name, version);
-    const openPromise = wrap(request);
-    if (upgrade) {
-        request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-        });
-    }
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event.newVersion, event));
-    }
-    openPromise
-        .then((db) => {
-        if (terminated)
-            db.addEventListener('close', () => terminated());
-        if (blocking) {
-            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
-        }
-    })
-        .catch(() => { });
-    return openPromise;
-}
-/**
- * Delete a database.
- *
- * @param name Name of the database.
- */
-function deleteDB(name, { blocked } = {}) {
-    const request = indexedDB.deleteDatabase(name);
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event));
-    }
-    return wrap(request).then(() => undefined);
-}
-
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-    if (!(target instanceof IDBDatabase &&
-        !(prop in target) &&
-        typeof prop === 'string')) {
-        return;
-    }
-    if (cachedMethods.get(prop))
-        return cachedMethods.get(prop);
-    const targetFuncName = prop.replace(/FromIndex$/, '');
-    const useIndex = prop !== targetFuncName;
-    const isWrite = writeMethods.includes(targetFuncName);
-    if (
-    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
-        !(isWrite || readMethods.includes(targetFuncName))) {
-        return;
-    }
-    const method = async function (storeName, ...args) {
-        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-        let target = tx.store;
-        if (useIndex)
-            target = target.index(args.shift());
-        // Must reject if op rejects.
-        // If it's a write operation, must reject if tx.done rejects.
-        // Must reject with op rejection first.
-        // Must resolve with op value.
-        // Must handle both promises (no unhandled rejections)
-        return (await Promise.all([
-            target[targetFuncName](...args),
-            isWrite && tx.done,
-        ]))[0];
-    };
-    cachedMethods.set(prop, method);
-    return method;
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
-}));
-
-const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
-const methodMap = {};
-const advanceResults = new WeakMap();
-const ittrProxiedCursorToOriginalProxy = new WeakMap();
-const cursorIteratorTraps = {
-    get(target, prop) {
-        if (!advanceMethodProps.includes(prop))
-            return target[prop];
-        let cachedFunc = methodMap[prop];
-        if (!cachedFunc) {
-            cachedFunc = methodMap[prop] = function (...args) {
-                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-            };
-        }
-        return cachedFunc;
-    },
-};
-async function* iterate(...args) {
-    // tslint:disable-next-line:no-this-assignment
-    let cursor = this;
-    if (!(cursor instanceof IDBCursor)) {
-        cursor = await cursor.openCursor(...args);
-    }
-    if (!cursor)
-        return;
-    cursor = cursor;
-    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-    // Map this double-proxy back to the original, so other cursor methods work.
-    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-    while (cursor) {
-        yield proxiedCursor;
-        // If one of the advancing methods was not called, call continue().
-        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-        advanceResults.delete(proxiedCursor);
-    }
-}
-function isIteratorProp(target, prop) {
-    return ((prop === Symbol.asyncIterator &&
-        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
-        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get(target, prop, receiver) {
-        if (isIteratorProp(target, prop))
-            return iterate;
-        return oldTraps.get(target, prop, receiver);
-    },
-    has(target, prop) {
-        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-    },
-}));
-
-const log$c = createPrefixedLogger('CACHE-WEB');
-/**
- * Web cache adapter using IndexedDB with automatic error recovery
- * Cache never expires - data persists until explicitly invalidated
- */
-class WebCacheAdapter {
-    constructor(options = {}) {
-        this.db = null;
-        this.initPromise = null;
-        this.retryCount = 0;
-        this.maxRetries = 3;
-        this.options = {
-            maxSize: 50 * 1024 * 1024, // 50MB
-            maxEntries: 10000,
-            compression: false,
-            compressionThreshold: 1024,
-            ...options,
-        };
-        this.initPromise = this.initialize();
-    }
-    async initialize() {
-        if (this.db)
-            return;
-        log$c.debug('Initializing IndexedDB cache', {
-            dbName: WebCacheAdapter.DB_NAME,
-            version: WebCacheAdapter.DB_VERSION,
-        });
-        try {
-            this.db = await this.openDatabase();
-            log$c.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$c.debug('Failed to initialize IndexedDB', { error: errorMessage });
-            // Check if this is a version conflict error
-            if (this.isVersionConflictError(errorMessage)) {
-                await this.handleVersionConflict();
-            }
-            else {
-                throw new Error(`Failed to initialize IndexedDB: ${errorMessage}`);
-            }
-        }
-    }
-    async openDatabase() {
-        return await openDB(WebCacheAdapter.DB_NAME, WebCacheAdapter.DB_VERSION, {
-            upgrade: (db, oldVersion, newVersion, transaction) => {
-                log$c.debug('Database upgrade needed', { oldVersion, newVersion });
-                this.handleUpgrade(db, oldVersion, newVersion, transaction);
-            },
-            blocked: () => {
-                log$c.debug('Database blocked - another tab may be open');
-            },
-            blocking: () => {
-                log$c.debug('Database blocking - will close connection');
-                if (this.db) {
-                    this.db.close();
-                    this.db = null;
-                }
-            },
-            terminated: () => {
-                log$c.debug('Database connection terminated unexpectedly');
-                this.db = null;
-            },
-        });
-    }
-    handleUpgrade(db, oldVersion, newVersion, transaction) {
-        log$c.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$c.debug('Created cache store and timestamp index');
-        }
-        // Handle migration from version 1 to 2
-        if (oldVersion < 2) {
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            // Remove unused indexes from simplified cache structure
-            const indexesToRemove = ['tags', 'source', 'syncStatus'];
-            indexesToRemove.forEach((indexName) => {
-                try {
-                    if (store.indexNames.contains(indexName)) {
-                        store.deleteIndex(indexName);
-                        log$c.debug(`Removed unused index: ${indexName}`);
-                    }
-                }
-                catch (error) {
-                    // Ignore errors if indexes don't exist
-                    log$c.debug(`Warning: Could not remove index ${indexName}`, error);
-                }
-            });
-        }
-        log$c.debug('Database upgrade completed');
-    }
-    isVersionConflictError(errorMessage) {
-        return (errorMessage.includes('less than the existing version') ||
-            errorMessage.includes('version conflict') ||
-            errorMessage.includes('VersionError'));
-    }
-    async handleVersionConflict() {
-        log$c.debug('Handling version conflict, attempting recovery...');
-        if (this.retryCount >= this.maxRetries) {
-            throw new Error('Failed to resolve IndexedDB version conflict after multiple attempts');
-        }
-        this.retryCount++;
-        try {
-            // Close any existing connection
-            if (this.db) {
-                this.db.close();
-                this.db = null;
-            }
-            // Delete the problematic database
-            log$c.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$c.debug(`Retrying database initialization (attempt ${this.retryCount}/${this.maxRetries})`);
-            this.db = await this.openDatabase();
-            log$c.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$c.debug('Recovery attempt failed', { attempt: this.retryCount, error: retryErrorMessage });
-            if (this.retryCount < this.maxRetries) {
-                // Try again
-                await this.handleVersionConflict();
-            }
-            else {
-                throw new Error(`Failed to recover from IndexedDB version conflict: ${retryErrorMessage}`);
-            }
-        }
-    }
-    async get(key) {
-        await this.ensureInitialized();
-        log$c.debug('Getting cache item', { key });
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            const result = await store.get(key);
-            if (!result) {
-                return null;
-            }
-            const item = result;
-            // Handle decompression if needed
-            const isCompressed = !!item.compressed;
-            let finalData;
-            if (isCompressed) {
-                const decompressed = decompressData(item.data, true);
-                finalData = JSON.parse(decompressed.data);
-            }
-            else {
-                finalData = item.data;
-            }
-            return {
-                data: finalData,
-                timestamp: item.timestamp,
-                compressed: isCompressed,
-            };
-        }
-        catch (error) {
-            log$c.debug('Error getting cache item', { key, error });
-            return null; // Return null on error instead of throwing
-        }
-    }
-    async set(key, data) {
-        const item = {
-            data,
-            timestamp: Date.now(),
-        };
-        return this.setItem(key, item);
-    }
-    async setItem(key, item) {
-        await this.ensureInitialized();
-        // Handle compression if enabled
-        let finalData = item.data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(item.data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-                log$c.debug('Compression result', {
-                    key,
-                    originalSize: compressionResult.originalSize,
-                    compressedSize: compressionResult.compressedSize,
-                    compressed: isCompressed,
-                    savings: compressionResult.originalSize - compressionResult.compressedSize,
-                });
-            }
-        }
-        log$c.debug('Setting cache item', { key, timestamp: item.timestamp, compressed: isCompressed });
-        const storedItem = {
-            key,
-            data: finalData,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
-        };
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.put(storedItem);
-        }
-        catch (error) {
-            log$c.debug('Error setting cache item', { key, error });
-            // Silently fail for cache writes
-        }
-    }
-    async setBatch(items) {
-        if (items.length === 0)
-            return;
-        await this.ensureInitialized();
-        log$c.debug('Batch setting items', { count: items.length });
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            // Process all items in the transaction
-            const promises = items.map(([key, item]) => {
-                const storedItem = this.prepareBatchItem(key, item);
-                return store.put(storedItem);
-            });
-            await Promise.all(promises);
-            log$c.debug('Batch operation completed', { count: items.length });
-        }
-        catch (error) {
-            log$c.debug('Error in batch operation', { count: items.length, error });
-            // Silently fail for batch writes
-        }
-    }
-    prepareBatchItem(key, item) {
-        // Handle compression if enabled (same logic as setItem)
-        let finalData = item.data;
-        let isCompressed = false;
-        if (this.options.compression && this.options.compressionThreshold) {
-            const serializedData = JSON.stringify(item.data);
-            const compressionResult = compressData(serializedData, this.options.compressionThreshold);
-            if (compressionResult.compressed) {
-                finalData = compressionResult.data;
-                isCompressed = true;
-            }
-        }
-        return {
-            key,
-            data: finalData,
-            timestamp: item.timestamp,
-            compressed: isCompressed,
-        };
-    }
-    async invalidate(pattern) {
-        await this.ensureInitialized();
-        const keys = await this.getKeys(pattern);
-        const deletePromises = keys.map((key) => this.delete(key));
-        await Promise.all(deletePromises);
-    }
-    async clear() {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.clear();
-            log$c.debug('Cache cleared successfully');
-        }
-        catch (error) {
-            log$c.debug('Error clearing cache', error);
-            // Silently fail for cache clear
-        }
-    }
-    async getSize() {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            let entries = 0;
-            let bytes = 0;
-            // Use cursor for efficient iteration
-            let cursor = await store.openCursor();
-            while (cursor) {
-                entries++;
-                // Rough estimation of size
-                bytes += JSON.stringify(cursor.value).length * 2; // UTF-16 encoding
-                cursor = await cursor.continue();
-            }
-            return {
-                entries,
-                bytes,
-                lastCleanup: Date.now(),
-            };
-        }
-        catch (error) {
-            log$c.debug('Error getting cache size', error);
-            return {
-                entries: 0,
-                bytes: 0,
-                lastCleanup: Date.now(),
-            };
-        }
-    }
-    async cleanup() {
-        // No cleanup needed - cache never expires
-        return 0;
-    }
-    async getKeys(pattern) {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readonly');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            const allKeys = (await store.getAllKeys());
-            if (!pattern) {
-                return allKeys;
-            }
-            const regex = this.patternToRegex(pattern);
-            return allKeys.filter((key) => regex.test(key));
-        }
-        catch (error) {
-            log$c.debug('Error getting cache keys', error);
-            return [];
-        }
-    }
-    async delete(key) {
-        await this.ensureInitialized();
-        try {
-            const transaction = this.db.transaction([WebCacheAdapter.STORE_NAME], 'readwrite');
-            const store = transaction.objectStore(WebCacheAdapter.STORE_NAME);
-            await store.delete(key);
-            return true;
-        }
-        catch (error) {
-            log$c.debug('Error deleting cache item', { key, error });
-            return false;
-        }
-    }
-    async ensureInitialized() {
-        if (!this.initPromise) {
-            this.initPromise = this.initialize();
-        }
-        try {
-            await this.initPromise;
-        }
-        catch (error) {
-            log$c.debug('Failed to ensure initialization', error);
-            // Reset and try once more
-            this.initPromise = null;
-            this.db = null;
-            this.initPromise = this.initialize();
-            await this.initPromise;
-        }
-    }
-    patternToRegex(pattern) {
-        // Convert simple glob patterns to regex
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-        const regexPattern = escaped.replace(/\\\*/g, '.*').replace(/\\\?/g, '.');
-        return new RegExp(`^${regexPattern}$`);
-    }
-}
-WebCacheAdapter.DB_NAME = 'acube_cache';
-WebCacheAdapter.DB_VERSION = 2;
-WebCacheAdapter.STORE_NAME = 'cache_entries';
-
-const log$b = createPrefixedLogger('CACHE-LOADER');
-function loadCacheAdapter(platform) {
-    try {
-        switch (platform) {
-            case 'web':
-                return new WebCacheAdapter({
-                    maxSize: 50 * 1024 * 1024,
-                    maxEntries: 10000,
-                    compression: false,
-                });
-            case 'react-native':
-                try {
-                    return new ReactNativeCacheAdapter({
-                        maxSize: 100 * 1024 * 1024,
-                        maxEntries: 15000,
-                    });
-                }
-                catch {
-                    return new MemoryCacheAdapter({
-                        maxSize: 10 * 1024 * 1024,
-                        maxEntries: 5000,
-                    });
+            hasCertificate: false,
+            certificateInfo: null,
+            platformInfo: this.mtlsAdapter?.getPlatformInfo() || null,
+            pendingRequestsCount: this.pendingRequests.size,
+        };
+        if (this.certificatePort) {
+            try {
+                status.hasCertificate = await this.certificatePort.hasCertificate();
+                if (status.hasCertificate) {
+                    status.certificateInfo = await this.certificatePort.getCertificateInfo();
                 }
-            case 'node':
-            default:
-                return new MemoryCacheAdapter({
-                    maxSize: 10 * 1024 * 1024,
-                    maxEntries: 5000,
-                });
+            }
+            catch {
+                // Ignore errors
+            }
         }
+        status.isReady = await this.isMtlsReady();
+        return status;
     }
-    catch (error) {
-        log$b.warn(`Cache adapter not available for platform ${platform}:`, error);
-        return undefined;
+    clearPendingRequests() {
+        this.pendingRequests.clear();
     }
 }
 
@@ -5222,7 +3335,7 @@ class BaseSecureStorageAdapter {
     }
 }
 
-const log$a = createPrefixedLogger('NETWORK-BASE');
+const log$8 = createPrefixedLogger('NETWORK-BASE');
 class NetworkBase {
     constructor(initialOnline = true, debounceMs = 300) {
         this.destroy$ = new Subject();
@@ -5242,14 +3355,14 @@ class NetworkBase {
         const current = this.statusSubject.getValue();
         if (current.online !== online) {
             this.statusSubject.next({ online, timestamp: Date.now() });
-            log$a.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
+            log$8.debug(`Network status changed: ${online ? 'online' : 'offline'}`);
         }
     }
     destroy() {
         this.destroy$.next();
         this.destroy$.complete();
         this.statusSubject.complete();
-        log$a.debug('Network monitor destroyed');
+        log$8.debug('Network monitor destroyed');
     }
 }
 
@@ -5309,7 +3422,7 @@ class NodeSecureStorageAdapter extends BaseSecureStorageAdapter {
     }
 }
 
-const log$9 = createPrefixedLogger('RN-STORAGE');
+const log$7 = createPrefixedLogger('RN-STORAGE');
 /**
  * React Native storage adapter using AsyncStorage
  * Note: Uses native batch operations for better performance (not base class)
@@ -5341,7 +3454,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getItem(key);
         }
         catch (error) {
-            log$9.error('Failed to get item from AsyncStorage:', error);
+            log$7.error('Failed to get item from AsyncStorage:', error);
             return null;
         }
     }
@@ -5382,7 +3495,7 @@ class ReactNativeStorageAdapter {
             return await this.AsyncStorage.getAllKeys();
         }
         catch (error) {
-            log$9.error('Failed to get all keys:', error);
+            log$7.error('Failed to get all keys:', error);
             return [];
         }
     }
@@ -5399,7 +3512,7 @@ class ReactNativeStorageAdapter {
             return result;
         }
         catch (error) {
-            log$9.error('Failed to get multiple items:', error);
+            log$7.error('Failed to get multiple items:', error);
             const result = {};
             keys.forEach((key) => {
                 result[key] = null;
@@ -5449,7 +3562,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$9.debug('expo-secure-store not available, trying react-native-keychain');
+            log$7.debug('expo-secure-store not available, trying react-native-keychain');
         }
         try {
             const Keychain = require('react-native-keychain');
@@ -5458,7 +3571,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             return;
         }
         catch {
-            log$9.error('react-native-keychain not available');
+            log$7.error('react-native-keychain not available');
         }
         throw new Error('No secure storage available. Please install expo-secure-store or react-native-keychain');
     }
@@ -5476,7 +3589,7 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
             }
         }
         catch (error) {
-            log$9.error('Failed to get secure item:', error);
+            log$7.error('Failed to get secure item:', error);
         }
         return null;
     }
@@ -5513,10 +3626,10 @@ class ReactNativeSecureStorageAdapter extends BaseSecureStorageAdapter {
         }
     }
     async clear() {
-        log$9.warn('Clear all secure items not fully implemented for React Native');
+        log$7.warn('Clear all secure items not fully implemented for React Native');
     }
     async getAllKeys() {
-        log$9.warn('Get all secure keys not implemented for React Native');
+        log$7.warn('Get all secure keys not implemented for React Native');
         return [];
     }
     async isAvailable() {
@@ -5734,7 +3847,7 @@ class NodeNetworkMonitor extends NetworkBase {
     }
 }
 
-const log$8 = createPrefixedLogger('RN-NETWORK');
+const log$6 = createPrefixedLogger('RN-NETWORK');
 /**
  * React Native network monitor using RxJS
  * Supports both @react-native-community/netinfo and expo-network
@@ -5747,7 +3860,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         this.moduleReady$ = new Subject();
         this.isExpo = detectPlatform().isExpo;
         this.init().catch((error) => {
-            log$8.error('Network monitor initialization failed:', error);
+            log$6.error('Network monitor initialization failed:', error);
         });
     }
     async init() {
@@ -5766,10 +3879,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('@react-native-community/netinfo');
             this.netInfoModule = module.default || module;
-            log$8.debug('Loaded @react-native-community/netinfo module');
+            log$6.debug('Loaded @react-native-community/netinfo module');
         }
         catch (error) {
-            log$8.error('Failed to load React Native NetInfo module:', error);
+            log$6.error('Failed to load React Native NetInfo module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5777,10 +3890,10 @@ class ReactNativeNetworkMonitor extends NetworkBase {
         try {
             const module = require('expo-network');
             this.netInfoModule = module.default || module;
-            log$8.debug('Loaded expo-network module');
+            log$6.debug('Loaded expo-network module');
         }
         catch (error) {
-            log$8.error('Failed to load Expo Network module:', error);
+            log$6.error('Failed to load Expo Network module:', error);
             this.netInfoModule = null;
         }
     }
@@ -5797,16 +3910,16 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             }
             const online = !!(state.isConnected && state.isInternetReachable !== false);
             this.updateStatus(online);
-            log$8.debug('Initial network state:', online ? 'online' : 'offline');
+            log$6.debug('Initial network state:', online ? 'online' : 'offline');
         }
         catch (error) {
-            log$8.warn('Could not fetch initial network state:', error);
+            log$6.warn('Could not fetch initial network state:', error);
         }
     }
     subscribeToStateChanges() {
         if (!this.netInfoModule)
             return;
-        log$8.debug('Subscribing to network state changes');
+        log$6.debug('Subscribing to network state changes');
         const handleState = (state) => {
             const online = !!(state.isConnected && (state.isInternetReachable ?? true));
             this.updateStatus(online);
@@ -5848,7 +3961,7 @@ class ReactNativeNetworkMonitor extends NetworkBase {
             };
         }
         catch (error) {
-            log$8.error('Failed to fetch detailed network info:', error);
+            log$6.error('Failed to fetch detailed network info:', error);
             return null;
         }
     }
@@ -5984,7 +4097,7 @@ class CertificateValidator {
     }
 }
 
-const log$7 = createPrefixedLogger('RN-MTLS');
+const log$5 = createPrefixedLogger('RN-MTLS');
 /**
  * React Native mTLS Adapter using @a-cube-io/expo-mutual-tls
  */
@@ -6006,7 +4119,7 @@ class ReactNativeMTLSAdapter {
             this.expoMTLS = ExpoMutualTls;
             // Set up debug logging with the correct event signature
             const debugListener = ExpoMutualTls.onDebugLog((event) => {
-                log$7.debug(`${event.type}: ${event.message}`, {
+                log$5.debug(`${event.type}: ${event.message}`, {
                     method: event.method,
                     url: event.url,
                     statusCode: event.statusCode,
@@ -6016,28 +4129,28 @@ class ReactNativeMTLSAdapter {
             this.eventListeners.push(debugListener);
             // Set up error logging with the correct event signature
             const errorListener = ExpoMutualTls.onError((event) => {
-                log$7.error(event.message, {
+                log$5.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$7.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
+                log$5.warn(`Certificate ${event.subject} expires at ${new Date(event.expiry)}`, {
                     alias: event.alias,
                     warning: event.warning,
                 });
             });
             this.eventListeners.push(expiryListener);
-            log$7.debug('Expo mTLS module loaded successfully');
+            log$5.debug('Expo mTLS module loaded successfully');
         }
         catch (error) {
-            log$7.warn('@a-cube-io/expo-mutual-tls not available:', error);
+            log$5.warn('@a-cube-io/expo-mutual-tls not available:', error);
         }
     }
     async isMTLSSupported() {
         const supported = this.expoMTLS !== null;
-        log$7.debug('mTLS support check:', {
+        log$5.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             moduleAvailable: !!this.expoMTLS,
@@ -6049,7 +4162,7 @@ class ReactNativeMTLSAdapter {
             throw new MTLSError(exports.MTLSErrorType.NOT_SUPPORTED, 'Expo mTLS module not available');
         }
         this.config = config;
-        log$7.debug('Initialized with config:', {
+        log$5.debug('Initialized with config:', {
             baseUrl: config.baseUrl,
             port: config.port,
             timeout: config.timeout,
@@ -6063,7 +4176,7 @@ class ReactNativeMTLSAdapter {
         if (!this.config) {
             throw new MTLSError(exports.MTLSErrorType.CONFIGURATION_ERROR, 'Adapter not initialized. Call initialize() first.');
         }
-        log$7.debug('Configuring certificate:', {
+        log$5.debug('Configuring certificate:', {
             format: certificateData.format,
             hasPassword: !!certificateData.password,
             certificateLength: certificateData.certificate.length,
@@ -6080,14 +4193,14 @@ class ReactNativeMTLSAdapter {
                 'client-key-service', // keyService
                 true // enableLogging - let the native module handle its own debug logging
                 );
-                log$7.debug('PEM services configured:', configResult);
+                log$5.debug('PEM services configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(exports.MTLSErrorType.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$7.debug('PEM certificate store result:', storeResult);
+                log$5.debug('PEM certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(exports.MTLSErrorType.CERTIFICATE_INVALID, 'Failed to store PEM certificate');
                 }
@@ -6100,14 +4213,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$7.debug('P12 service configured:', configResult);
+                log$5.debug('P12 service configured:', configResult);
                 if (!configResult.success) {
                     throw new MTLSError(exports.MTLSErrorType.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$7.debug('P12 certificate store result:', storeResult);
+                log$5.debug('P12 certificate store result:', storeResult);
                 if (!storeResult) {
                     throw new MTLSError(exports.MTLSErrorType.CERTIFICATE_INVALID, 'Failed to store P12 certificate');
                 }
@@ -6121,7 +4234,7 @@ class ReactNativeMTLSAdapter {
             if (error instanceof MTLSError) {
                 throw error;
             }
-            log$7.error('Certificate configuration failed:', error);
+            log$5.error('Certificate configuration failed:', error);
             throw new MTLSError(exports.MTLSErrorType.CONFIGURATION_ERROR, 'Failed to configure certificate', error);
         }
     }
@@ -6132,38 +4245,38 @@ class ReactNativeMTLSAdapter {
         try {
             // Use static method call
             const hasCert = await this.expoMTLS.hasCertificate();
-            log$7.debug('Certificate availability check:', hasCert);
+            log$5.debug('Certificate availability check:', hasCert);
             return hasCert;
         }
         catch (error) {
-            log$7.error('Certificate check failed:', error);
+            log$5.error('Certificate check failed:', error);
             return false;
         }
     }
     async getCertificateInfo() {
         if (!this.expoMTLS) {
-            log$7.debug('Certificate info requested but module not available');
+            log$5.debug('Certificate info requested but module not available');
             return null;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$7.debug('No certificate stored');
+                log$5.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$7.debug('No certificate information available');
+                log$5.debug('No certificate information available');
                 return null;
             }
             // Get the first certificate (primary client certificate)
             const cert = result.certificates[0];
             if (!cert) {
-                log$7.debug('Certificate data is empty');
+                log$5.debug('Certificate data is empty');
                 return null;
             }
-            log$7.debug('Retrieved certificate info:', {
+            log$5.debug('Retrieved certificate info:', {
                 subject: cert.subject.commonName,
                 issuer: cert.issuer.commonName,
                 validFrom: new Date(cert.validFrom),
@@ -6182,7 +4295,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$7.error('Failed to get certificate info:', error);
+            log$5.error('Failed to get certificate info:', error);
             return null;
         }
     }
@@ -6193,7 +4306,7 @@ class ReactNativeMTLSAdapter {
      */
     async parseCertificateData(certificateData) {
         if (!this.expoMTLS) {
-            log$7.debug('Parse certificate: Module not available');
+            log$5.debug('Parse certificate: Module not available');
             return null;
         }
         try {
@@ -6210,14 +4323,14 @@ class ReactNativeMTLSAdapter {
             else {
                 throw new MTLSError(exports.MTLSErrorType.CERTIFICATE_INVALID, `Unsupported certificate format: ${certificateData.format}`);
             }
-            log$7.debug('Certificate parsed successfully:', {
+            log$5.debug('Certificate parsed successfully:', {
                 certificateCount: result.certificates.length,
                 subjects: result.certificates.map((cert) => cert.subject.commonName),
             });
             return result;
         }
         catch (error) {
-            log$7.error('Failed to parse certificate:', error);
+            log$5.error('Failed to parse certificate:', error);
             if (error instanceof MTLSError) {
                 throw error;
             }
@@ -6232,7 +4345,7 @@ class ReactNativeMTLSAdapter {
         if (!hasCert) {
             throw new MTLSError(exports.MTLSErrorType.CERTIFICATE_NOT_FOUND, 'No certificate configured');
         }
-        log$7.debug('Making mTLS request:', {
+        log$5.debug('Making mTLS request:', {
             method: requestConfig.method || 'GET',
             url: requestConfig.url,
             headers: requestConfig.headers,
@@ -6240,7 +4353,7 @@ class ReactNativeMTLSAdapter {
             responseType: requestConfig.responseType,
         });
         if (requestConfig.data) {
-            log$7.debug('mTLS request body:', requestConfig.data);
+            log$5.debug('mTLS request body:', requestConfig.data);
         }
         try {
             const response = await this.expoMTLS.request(requestConfig.url, {
@@ -6249,7 +4362,7 @@ class ReactNativeMTLSAdapter {
                 body: requestConfig.data ? JSON.stringify(requestConfig.data) : undefined,
                 responseType: requestConfig.responseType,
             });
-            log$7.debug('mTLS request successful:', response);
+            log$5.debug('mTLS request successful:', response);
             if (!response.success) {
                 throw new MTLSError(exports.MTLSErrorType.CONNECTION_FAILED, `mTLS request failed: ${response.statusMessage} (${response.statusCode})`, undefined, response.statusCode);
             }
@@ -6261,7 +4374,7 @@ class ReactNativeMTLSAdapter {
                     data = JSON.parse(response.body);
                 }
                 catch (parseError) {
-                    log$7.warn('Failed to parse JSON response:', parseError);
+                    log$5.warn('Failed to parse JSON response:', parseError);
                     // If parsing fails, keep raw body
                 }
             }
@@ -6278,7 +4391,7 @@ class ReactNativeMTLSAdapter {
             };
         }
         catch (error) {
-            log$7.error('mTLS request failed:', error);
+            log$5.error('mTLS request failed:', error);
             throw new MTLSError(exports.MTLSErrorType.CONNECTION_FAILED, 'mTLS request failed', error);
         }
     }
@@ -6291,18 +4404,18 @@ class ReactNativeMTLSAdapter {
      */
     async testConnection() {
         if (!this.expoMTLS || !this.config) {
-            log$7.debug('Diagnostic test: No mTLS module or config available');
+            log$5.debug('Diagnostic test: No mTLS module or config available');
             return false;
         }
         try {
             const hasCert = await this.hasCertificate();
             if (!hasCert) {
-                log$7.debug('Diagnostic test: No certificate configured');
+                log$5.debug('Diagnostic test: No certificate configured');
                 return false;
             }
-            log$7.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
+            log$5.debug('Running diagnostic test (may fail even if mTLS works):', this.config.baseUrl);
             const result = await this.expoMTLS.testConnection(this.config.baseUrl);
-            log$7.debug('Diagnostic test result (NOT validation):', {
+            log$5.debug('Diagnostic test result (NOT validation):', {
                 success: result.success,
                 statusCode: result.statusCode,
                 statusMessage: result.statusMessage,
@@ -6313,13 +4426,13 @@ class ReactNativeMTLSAdapter {
             return result.success;
         }
         catch (error) {
-            log$7.warn('Diagnostic test failed (this is expected):', error);
+            log$5.warn('Diagnostic test failed (this is expected):', error);
             return false;
         }
     }
     async removeCertificate() {
         if (!this.expoMTLS) {
-            log$7.debug('Remove certificate: Module not available');
+            log$5.debug('Remove certificate: Module not available');
             return;
         }
         try {
@@ -6328,10 +4441,10 @@ class ReactNativeMTLSAdapter {
             this.isConfigured = false;
             // Cleanup event listeners
             this.cleanupEventListeners();
-            log$7.debug('Certificate removed successfully');
+            log$5.debug('Certificate removed successfully');
         }
         catch (error) {
-            log$7.error('Failed to remove certificate:', error);
+            log$5.error('Failed to remove certificate:', error);
             throw new MTLSError(exports.MTLSErrorType.CONFIGURATION_ERROR, 'Failed to remove certificate', error);
         }
     }
@@ -6340,7 +4453,7 @@ class ReactNativeMTLSAdapter {
      */
     cleanupEventListeners() {
         if (this.eventListeners.length > 0) {
-            log$7.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
+            log$5.debug(`Cleaning up ${this.eventListeners.length} event listeners`);
         }
         // Remove individual listeners if they have remove methods
         this.eventListeners.forEach((listener) => {
@@ -6377,7 +4490,7 @@ class ReactNativeMTLSAdapter {
     }
 }
 
-const log$6 = createPrefixedLogger('WEB-MTLS');
+const log$4 = createPrefixedLogger('WEB-MTLS');
 /**
  * Web mTLS Adapter - Graceful fallback for web browsers
  *
@@ -6391,13 +4504,13 @@ const log$6 = createPrefixedLogger('WEB-MTLS');
  */
 class WebMTLSAdapter {
     constructor() {
-        log$6.warn('Web browsers do not support programmatic mTLS configuration');
-        log$6.info('Use JWT authentication or configure client certificates in browser settings');
+        log$4.warn('Web browsers do not support programmatic mTLS configuration');
+        log$4.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$6.debug('mTLS support check:', {
+        log$4.debug('mTLS support check:', {
             supported,
             platform: this.getPlatformInfo().platform,
             reason: 'Browser security model prevents programmatic certificate configuration',
@@ -6406,14 +4519,14 @@ class WebMTLSAdapter {
         return supported;
     }
     async initialize(config) {
-        log$6.warn('Initialized but mTLS not available in web browsers:', {
+        log$4.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$6.error('Certificate configuration attempted:', {
+        log$4.error('Certificate configuration attempted:', {
             format: certificateData.format,
             reason: 'Not supported in web browsers',
             alternatives: [
@@ -6428,15 +4541,15 @@ class WebMTLSAdapter {
     }
     async hasCertificate() {
         // We cannot detect if the browser has certificates configured
-        log$6.debug('Certificate availability check: Cannot detect browser certificates programmatically');
+        log$4.debug('Certificate availability check: Cannot detect browser certificates programmatically');
         return false;
     }
     async getCertificateInfo() {
-        log$6.debug('Certificate info requested: Not accessible in web browsers');
+        log$4.debug('Certificate info requested: Not accessible in web browsers');
         return null;
     }
     async request(requestConfig) {
-        log$6.error('mTLS request attempted:', {
+        log$4.error('mTLS request attempted:', {
             method: requestConfig.method,
             url: requestConfig.url,
             reason: 'Not supported in web browsers',
@@ -6451,11 +4564,11 @@ class WebMTLSAdapter {
             'are properly configured in the browser certificate store.');
     }
     async testConnection() {
-        log$6.debug('Connection test: mTLS not available in web browsers');
+        log$4.debug('Connection test: mTLS not available in web browsers');
         return false;
     }
     async removeCertificate() {
-        log$6.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
+        log$4.debug('Remove certificate: No certificates to remove (not supported in web browsers)');
         // No-op - cannot remove certificates programmatically in browsers
     }
     /**
@@ -6463,7 +4576,7 @@ class WebMTLSAdapter {
      * Always returns null for web browsers as mTLS is not supported
      */
     getBaseUrl() {
-        log$6.debug('Base URL requested: Not supported in web browsers');
+        log$4.debug('Base URL requested: Not supported in web browsers');
         return null;
     }
     getPlatformInfo() {
@@ -6496,7 +4609,7 @@ class WebMTLSAdapter {
     }
 }
 
-const log$5 = createPrefixedLogger('MTLS-LOADER');
+const log$3 = createPrefixedLogger('MTLS-LOADER');
 function loadMTLSAdapter(platform, config) {
     try {
         let adapter;
@@ -6530,7 +4643,7 @@ function loadMTLSAdapter(platform, config) {
         return adapter;
     }
     catch (error) {
-        log$5.warn(`mTLS adapter not available for platform ${platform}:`, error);
+        log$3.warn(`mTLS adapter not available for platform ${platform}:`, error);
         return null;
     }
 }
@@ -6540,7 +4653,7 @@ async function initializeAdapterAsync(adapter, config) {
         if (isSupported) {
             await adapter.initialize(config);
             const platformInfo = adapter.getPlatformInfo();
-            log$5.debug('mTLS adapter initialized:', {
+            log$3.debug('mTLS adapter initialized:', {
                 platform: platformInfo.platform,
                 mtlsSupported: platformInfo.mtlsSupported,
                 certificateStorage: platformInfo.certificateStorage,
@@ -6549,31 +4662,28 @@ async function initializeAdapterAsync(adapter, config) {
         }
     }
     catch (error) {
-        log$5.warn('Failed to initialize mTLS adapter:', error);
+        log$3.warn('Failed to initialize mTLS adapter:', error);
     }
 }
 
-const log$4 = createPrefixedLogger('ADAPTER-LOADER');
+const log$2 = createPrefixedLogger('ADAPTER-LOADER');
 function loadPlatformAdapters(options = {}) {
     const { mtlsConfig } = options;
     const { platform } = detectPlatform();
-    log$4.debug('Loading adapters for platform:', platform);
+    log$2.debug('Loading adapters for platform:', platform);
     const storageAdapters = loadStorageAdapters(platform);
     const networkMonitor = loadNetworkMonitor(platform);
-    const cache = loadCacheAdapter(platform);
     const mtls = loadMTLSAdapter(platform, mtlsConfig);
-    log$4.debug('Adapters loaded:', {
+    log$2.debug('Adapters loaded:', {
         platform,
         hasStorage: !!storageAdapters.storage,
         hasSecureStorage: !!storageAdapters.secureStorage,
         hasNetworkMonitor: !!networkMonitor,
-        hasCache: !!cache,
         hasMTLS: !!mtls,
     });
     return {
         ...storageAdapters,
         networkMonitor,
-        cache,
         mtls: mtls || undefined,
     };
 }
@@ -6590,12 +4700,9 @@ function createACubeMTLSConfig(baseUrl, timeout, autoInitialize = true, forcePor
 
 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'),
@@ -6613,7 +4720,6 @@ const DI_TOKENS = {
     AUTH_SERVICE: Symbol('AUTH_SERVICE'),
     AUTHENTICATION_SERVICE: Symbol('AUTHENTICATION_SERVICE'),
     CERTIFICATE_SERVICE: Symbol('CERTIFICATE_SERVICE'),
-    OFFLINE_SERVICE: Symbol('OFFLINE_SERVICE'),
     NOTIFICATION_SERVICE: Symbol('NOTIFICATION_SERVICE'),
     TELEMETRY_SERVICE: Symbol('TELEMETRY_SERVICE'),
 };
@@ -7588,468 +5694,6 @@ class TelemetryRepositoryImpl {
     }
 }
 
-const log$3 = 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\/pems\/([^/]+)\/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\/pems\/([^/]+)$/, resource: 'point-of-sale' },
-    { pattern: /^\/mf1\/pems$/, 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\/pems\/([^/]+)\/certificates$/,
-        resource: 'pem',
-        action: 'certificates',
-    },
-    { pattern: /^\/mf2\/pems\/([^/]+)$/, resource: 'pem' },
-    // Others
-    { pattern: /^\/mf1\/notifications/, resource: 'notification', isList: true },
-    {
-        pattern: /^\/mf1\/pems\/([^/]+)\/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$3.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$3.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$3.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$3.debug('Generated special action cache key:', { url, key, resource, action });
-            return key;
-        }
-        let key = `${resource}:${ids.join(':')}`;
-        if (action) {
-            key += `:${action}`;
-        }
-        log$3.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$3.debug('No resource found for URL, using default TTL:', { url, ttl: DEFAULT_TTL });
-            return DEFAULT_TTL;
-        }
-        const ttl = this.config[resource].ttlMs;
-        log$3.debug('TTL for resource:', { url, resource, ttlMs: ttl, ttlMin: ttl / 60000 });
-        return ttl;
-    }
-    shouldCache(url) {
-        const parsed = this.parseUrl(url);
-        if (!parsed) {
-            log$3.debug('URL not recognized, should not cache:', { url });
-            return false;
-        }
-        const { resource, isList } = parsed;
-        const config = this.config[resource];
-        if (isList) {
-            log$3.debug('List endpoint cache decision:', {
-                url,
-                resource,
-                isList: true,
-                shouldCache: config.cacheList,
-            });
-            return config.cacheList;
-        }
-        log$3.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$3.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$3.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$2 = 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$2.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$2.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$2.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$2.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$2.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$2.debug('Cache entry found:', {
-                    cacheKey,
-                    timestamp: new Date(cached.timestamp).toISOString(),
-                    ageMs: Date.now() - cached.timestamp,
-                });
-            }
-            else {
-                log$2.debug('Cache entry not found:', { cacheKey });
-            }
-        }
-        catch (error) {
-            log$2.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$2.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$2.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$2.info('CACHE STALE (offline):', {
-                    url,
-                    cacheKey,
-                    ageMs: age,
-                    durationMs: duration,
-                });
-                return {
-                    data: cached.data,
-                    status: 200,
-                    headers: { 'x-cache': 'STALE' },
-                };
-            }
-            log$2.debug('Cache expired, fetching fresh data:', { cacheKey, ageMs: age, ttlMs: ttl });
-        }
-        // Fetch fresh data
-        try {
-            log$2.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$2.debug('Response cached successfully:', { cacheKey });
-            }
-            catch (error) {
-                log$2.error('Failed to cache response:', {
-                    cacheKey,
-                    error: error instanceof Error ? error.message : error,
-                });
-            }
-            const duration = Date.now() - startTime;
-            log$2.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$2.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$2.error('Network error with no cache fallback:', {
-                url,
-                error: error instanceof Error ? error.message : error,
-            });
-            throw error;
-        }
-    }
-    async post(url, data, config) {
-        log$2.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$2.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$2.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$2.info('DELETE request:', { url });
-        const response = await this.http.delete(url, config);
-        await this.invalidateRelated(url, 'DELETE');
-        return response;
-    }
-    setAuthToken(token) {
-        log$2.debug('CachingHttpDecorator.setAuthToken called:', {
-            hasToken: !!token,
-            tokenPrefix: token?.substring(0, 20),
-            underlyingHttpType: this.http.constructor.name,
-        });
-        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$2.debug('No cache patterns to invalidate:', { url, method });
-            return;
-        }
-        log$2.info('Invalidating cache patterns:', { url, method, patterns });
-        for (const pattern of patterns) {
-            try {
-                await this.cache.invalidate(pattern);
-                log$2.debug('Cache pattern invalidated:', { pattern });
-            }
-            catch (error) {
-                log$2.error('Failed to invalidate pattern:', {
-                    pattern,
-                    error: error instanceof Error ? error.message : error,
-                });
-            }
-        }
-    }
-    destroy() {
-        log$2.debug('CachingHttpDecorator destroyed');
-        this.networkSubscription?.unsubscribe();
-    }
-}
-
 const logJwt = createPrefixedLogger('HTTP-JWT');
 const logMtls = createPrefixedLogger('HTTP-MTLS');
 class AxiosHttpAdapter {
@@ -8319,7 +5963,6 @@ 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);
@@ -8367,23 +6010,6 @@ 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);
@@ -8451,7 +6077,6 @@ class ACubeSDK {
                     mtlsConfig,
                 });
                 log$1.info('Platform adapters loaded', {
-                    hasCache: !!this.adapters.cache,
                     hasNetworkMonitor: !!this.adapters.networkMonitor,
                     hasMtls: !!this.adapters.mtls,
                     hasSecureStorage: !!this.adapters.secureStorage,
@@ -8467,25 +6092,10 @@ class ACubeSDK {
             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('HTTP ports initialized', {
-                httpPortType: httpPort.constructor.name,
-                baseHttpPortType: baseHttpPort.constructor.name,
-                areSameInstance: httpPort === baseHttpPort,
-            });
             log$1.debug('Initializing authentication service');
             this.authService = new AuthenticationService(httpPort, tokenStorage, {
                 authUrl: this.config.getAuthUrl(),
@@ -8496,27 +6106,9 @@ 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);
-                },
-                onOperationCompleted: (result) => {
-                    this.events.onOfflineOperationCompleted?.(result.operation.id, result.success);
-                },
-                onOperationFailed: (result) => {
-                    this.events.onOfflineOperationCompleted?.(result.operation.id, false);
-                },
-            };
-            this.offlineManager = new OfflineManager(this.adapters.storage, httpPort, this.adapters.networkMonitor, {
-                syncInterval: 30000,
-            }, queueEvents);
             this.networkSubscription = this.adapters.networkMonitor.online$.subscribe((online) => {
                 this.currentOnlineState = online;
                 this.events.onNetworkStatusChanged?.(online);
-                if (online && this.offlineManager) {
-                    this.offlineManager.sync().catch(() => { });
-                }
             });
             const isAuth = await this.authService.isAuthenticated();
             log$1.debug('Checking authentication status during init', { isAuthenticated: isAuth });
@@ -8534,12 +6126,12 @@ class ACubeSDK {
             else {
                 log$1.warn('User not authenticated during SDK init - token will be set after login');
             }
-            if (this.adapters?.mtls && 'setMTLSAdapter' in baseHttpPort) {
+            if (this.adapters?.mtls && 'setMTLSAdapter' in httpPort) {
                 log$1.debug('Connecting mTLS adapter to HTTP port');
-                const httpWithMtls = baseHttpPort;
+                const httpWithMtls = httpPort;
                 httpWithMtls.setMTLSAdapter(this.adapters.mtls);
             }
-            if ('setAuthStrategy' in baseHttpPort) {
+            if ('setAuthStrategy' in httpPort) {
                 log$1.debug('Configuring auth strategy');
                 const jwtHandler = new JwtAuthHandler(tokenStorage);
                 const certificatePort = this.certificateService
@@ -8571,7 +6163,7 @@ class ACubeSDK {
                     },
                 };
                 const authStrategy = new AuthStrategy(jwtHandler, mtlsHandler, userProvider, this.adapters?.mtls || null);
-                const httpWithStrategy = baseHttpPort;
+                const httpWithStrategy = httpPort;
                 httpWithStrategy.setAuthStrategy(authStrategy);
             }
             if (this.adapters?.mtls && this.certificateService) {
@@ -8596,7 +6188,6 @@ class ACubeSDK {
             }
             this.isInitialized = true;
             log$1.info('SDK initialized successfully', {
-                hasCache: !!this.adapters.cache,
                 hasMtls: !!this.adapters.mtls,
             });
         }
@@ -8687,10 +6278,6 @@ class ACubeSDK {
         this.ensureInitialized();
         return await this.authService.isAuthenticated();
     }
-    getOfflineManager() {
-        this.ensureInitialized();
-        return this.offlineManager;
-    }
     isOnline() {
         this.ensureInitialized();
         return this.currentOnlineState;
@@ -8818,7 +6405,6 @@ class ACubeSDK {
     }
     destroy() {
         this.networkSubscription?.unsubscribe();
-        this.offlineManager?.destroy();
         this.container?.clear();
         this.isInitialized = false;
     }
@@ -8843,6 +6429,7 @@ const INITIAL_STATE = {
         remainingMs: 0,
     },
     lastNotification: null,
+    certificateMissing: false,
 };
 class AppStateService {
     get state$() {
@@ -8857,28 +6444,33 @@ class AppStateService {
     get warning$() {
         return this.state$.pipe(map((s) => s.warning), distinctUntilChanged((a, b) => a.active === b.active && a.remainingMs === b.remainingMs));
     }
-    constructor(notifications$, networkPort) {
+    get certificateMissing$() {
+        return this.state$.pipe(map((s) => s.certificateMissing), distinctUntilChanged());
+    }
+    constructor(notifications$, networkPort, certificateMissingInput$ = of(false)) {
         this.notifications$ = notifications$;
         this.networkPort = networkPort;
+        this.certificateMissingInput$ = certificateMissingInput$;
         this.stateSubject = new BehaviorSubject(INITIAL_STATE);
         this.destroy$ = new Subject();
         this.warningTimerId = null;
         this.setupSubscriptions();
     }
     setupSubscriptions() {
-        combineLatest([this.notifications$, this.networkPort.online$])
+        combineLatest([this.notifications$, this.networkPort.online$, this.certificateMissingInput$])
             .pipe(takeUntil(this.destroy$))
-            .subscribe(([notifications, isOnline]) => {
-            this.processState(notifications, isOnline);
+            .subscribe(([notifications, isOnline, certificateMissing]) => {
+            this.processState(notifications, isOnline, certificateMissing);
         });
     }
-    processState(notifications, isOnline) {
+    processState(notifications, isOnline, certificateMissing) {
         if (!isOnline) {
             this.updateState({
                 mode: 'OFFLINE',
                 isOnline: false,
                 warning: { active: false, blockAt: null, remainingMs: 0 },
                 lastNotification: null,
+                certificateMissing,
             });
             this.stopWarningTimer();
             return;
@@ -8940,6 +6532,7 @@ class AppStateService {
             isOnline: true,
             warning: warningState,
             lastNotification,
+            certificateMissing,
         });
     }
     getLatestNotificationByCode(notifications) {
@@ -9097,7 +6690,6 @@ class TelemetryService {
         this.events = events;
         this.stateSubject = new BehaviorSubject({
             data: null,
-            isCached: false,
             isLoading: false,
             lastFetchedAt: null,
         });
@@ -9167,7 +6759,6 @@ class TelemetryService {
             const data = await this.repository.getTelemetry(this.currentPemId);
             const newState = {
                 data,
-                isCached: false,
                 isLoading: false,
                 lastFetchedAt: Date.now(),
             };
@@ -9192,7 +6783,6 @@ class TelemetryService {
     clearTelemetry() {
         this.stateSubject.next({
             data: null,
-            isCached: false,
             isLoading: false,
             lastFetchedAt: null,
         });
@@ -9205,6 +6795,7 @@ class TelemetryService {
     }
 }
 
+const log = createPrefixedLogger('SDK-MANAGER');
 /**
  * SDKManager - Singleton wrapper for ACubeSDK with simplified API
  *
@@ -9255,6 +6846,7 @@ class SDKManager {
         this.appStateService = null;
         this.isInitialized = false;
         this.isPollingActive = false;
+        this.certificateMissingSubject = new BehaviorSubject(false);
         /**
          * Handle user state changes (login/logout/token expiration)
          * Manages polling lifecycle based on user role
@@ -9265,9 +6857,14 @@ class SDKManager {
             if (!this.isInitialized)
                 return;
             if (user) {
-                // User logged in - check role and start polling if allowed
+                // User logged in - check role and certificate before starting polling
                 const canPoll = hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
                 if (canPoll && !this.isPollingActive) {
+                    const hasCert = await this.checkCertificate();
+                    if (!hasCert) {
+                        log.warn('Certificate missing — polling blocked until certificate is installed');
+                        return;
+                    }
                     this.notificationService?.startPolling();
                     await this.startTelemetryPollingAuto();
                     this.isPollingActive = true;
@@ -9281,6 +6878,7 @@ class SDKManager {
                     this.telemetryService?.clearTelemetry();
                     this.isPollingActive = false;
                 }
+                this.certificateMissingSubject.next(false);
             }
         };
     }
@@ -9347,7 +6945,7 @@ class SDKManager {
         this.telemetryService = new TelemetryService(telemetryRepo, networkPort, {
             pollIntervalMs: this.config.telemetryPollIntervalMs ?? 60000,
         });
-        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort);
+        this.appStateService = new AppStateService(this.notificationService.notifications$, networkPort, this.certificateMissingSubject.asObservable());
         if (this.events?.onAppStateChanged) {
             this.appStateService.state$.subscribe(this.events.onAppStateChanged);
         }
@@ -9359,9 +6957,15 @@ class SDKManager {
         const user = await this.sdk.getCurrentUser();
         const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
         if (canPoll) {
-            this.notificationService.startPolling();
-            await this.startTelemetryPollingAuto();
-            this.isPollingActive = true;
+            const hasCert = await this.checkCertificate();
+            if (hasCert) {
+                this.notificationService.startPolling();
+                await this.startTelemetryPollingAuto();
+                this.isPollingActive = true;
+            }
+            else {
+                log.warn('Certificate missing at init — polling blocked until certificate is installed');
+            }
         }
         // AppStateService remains active for all users (handles OFFLINE network state)
     }
@@ -9396,7 +7000,14 @@ class SDKManager {
         return this.appStateService.warning$;
     }
     /**
-     * Observable stream of telemetry state (data, isLoading, isCached, error)
+     * Observable stream indicating if certificate is missing
+     * When true, polling is blocked and the user should install a certificate
+     */
+    get certificateMissing$() {
+        return this.certificateMissingSubject.asObservable();
+    }
+    /**
+     * Observable stream of telemetry state (data, isLoading, error)
      */
     get telemetryState$() {
         this.ensureInitialized();
@@ -9472,9 +7083,37 @@ class SDKManager {
             logout: () => sdk.logout(),
             getCurrentUser: () => sdk.getCurrentUser(),
             isAuthenticated: () => sdk.isAuthenticated(),
-            storeCertificate: (certificate, privateKey, options) => sdk.storeCertificate(certificate, privateKey, options),
+            storeCertificate: async (certificate, privateKey, options) => {
+                await sdk.storeCertificate(certificate, privateKey, options);
+                this.certificateMissingSubject.next(false);
+                // Start polling if user can poll and polling is not active
+                if (!this.isPollingActive) {
+                    const user = await sdk.getCurrentUser();
+                    const canPoll = user && hasAnyRole(user.roles, ['ROLE_MERCHANT', 'ROLE_CASHIER']);
+                    if (canPoll) {
+                        log.info('Certificate installed — starting polling');
+                        this.notificationService?.startPolling();
+                        await this.startTelemetryPollingAuto();
+                        this.isPollingActive = true;
+                    }
+                }
+            },
             hasCertificate: () => sdk.hasCertificate(),
-            clearCertificate: () => sdk.clearCertificate(),
+            clearCertificate: async () => {
+                await sdk.clearCertificate();
+                this.certificateMissingSubject.next(true);
+                // Stop polling since certificate is required
+                if (this.isPollingActive) {
+                    log.info('Certificate removed — stopping polling');
+                    this.notificationService?.stopPolling();
+                    this.telemetryService?.stopPolling();
+                    this.telemetryService?.clearTelemetry();
+                    this.isPollingActive = false;
+                }
+            },
+            getCertificate: () => sdk.getCertificate(),
+            getCertificatesInfo: () => sdk.getCertificatesInfo(),
+            notifications: sdk.notifications,
             isOnline: () => sdk.isOnline(),
         };
     }
@@ -9505,6 +7144,21 @@ class SDKManager {
         this.ensureInitialized();
         return this.sdk;
     }
+    /**
+     * Check certificate availability and update certificateMissing state.
+     * Returns true if certificate is available, false otherwise.
+     */
+    async checkCertificate() {
+        try {
+            const hasCert = await this.sdk.hasCertificate();
+            this.certificateMissingSubject.next(!hasCert);
+            return hasCert;
+        }
+        catch {
+            this.certificateMissingSubject.next(true);
+            return false;
+        }
+    }
     cleanup() {
         this.notificationService?.destroy();
         this.telemetryService?.destroy();
@@ -9530,91 +7184,6 @@ const RECEIPT_SENT = 'sent';
 const RECEIPT_SORT_DESCENDING = 'descending';
 const RECEIPT_SORT_ASCENDING = 'ascending';
 
-const log = createPrefixedLogger('CACHE-HANDLER');
-class CacheHandler {
-    constructor(cache, networkMonitor) {
-        this.cache = cache;
-        this.networkMonitor = networkMonitor;
-        this.currentOnlineState = true;
-        this.setupNetworkMonitoring();
-    }
-    setupNetworkMonitoring() {
-        if (this.networkMonitor) {
-            this.networkSubscription = this.networkMonitor.online$.subscribe((online) => {
-                this.currentOnlineState = online;
-            });
-        }
-    }
-    isOnline() {
-        if (this.networkMonitor) {
-            return this.currentOnlineState;
-        }
-        if (typeof navigator !== 'undefined' && 'onLine' in navigator) {
-            return navigator.onLine;
-        }
-        return false;
-    }
-    async handleCachedRequest(url, requestFn, config) {
-        if (!this.cache || config?.useCache === false) {
-            const response = await requestFn();
-            return response.data;
-        }
-        const cacheKey = this.generateCacheKey(url);
-        const online = this.isOnline();
-        log.debug('Request:', { url, cacheKey, online });
-        if (online) {
-            try {
-                const response = await requestFn();
-                if (this.cache) {
-                    await this.cache.set(cacheKey, response.data).catch((error) => {
-                        log.error('Failed to cache:', error instanceof Error ? error.message : error);
-                    });
-                }
-                return response.data;
-            }
-            catch (error) {
-                const cached = await this.cache.get(cacheKey).catch(() => null);
-                if (cached) {
-                    log.debug('Network failed, using cache fallback');
-                    return cached.data;
-                }
-                throw error;
-            }
-        }
-        else {
-            const cached = await this.cache.get(cacheKey).catch(() => null);
-            if (cached) {
-                log.debug('Offline, returning cached data');
-                return cached.data;
-            }
-            throw new Error('Offline: No cached data available');
-        }
-    }
-    generateCacheKey(url) {
-        return url;
-    }
-    async invalidateCache(pattern) {
-        if (!this.cache)
-            return;
-        try {
-            await this.cache.invalidate(pattern);
-        }
-        catch (error) {
-            log.error('Invalidation failed:', error instanceof Error ? error.message : error);
-        }
-    }
-    getCacheStatus() {
-        return {
-            available: !!this.cache,
-            networkMonitorAvailable: !!this.networkMonitor,
-            isOnline: this.isOnline(),
-        };
-    }
-    destroy() {
-        this.networkSubscription?.unsubscribe();
-    }
-}
-
 function transformError(error) {
     if (axios.isAxiosError(error)) {
         const response = error.response;
@@ -9802,7 +7371,6 @@ exports.AppStateService = AppStateService;
 exports.AuthStrategy = AuthStrategy;
 exports.AuthenticationService = AuthenticationService;
 exports.AxiosHttpAdapter = AxiosHttpAdapter;
-exports.CacheHandler = CacheHandler;
 exports.CashRegisterCreateSchema = CashRegisterCreateSchema;
 exports.CashRegisterMapper = CashRegisterMapper;
 exports.CashRegisterRepositoryImpl = CashRegisterRepositoryImpl;
@@ -9813,7 +7381,6 @@ exports.CertificateService = CertificateService;
 exports.CertificateValidator = CertificateValidator;
 exports.ConfigManager = ConfigManager;
 exports.DAILY_REPORT_STATUS_OPTIONS = DAILY_REPORT_STATUS_OPTIONS;
-exports.DEFAULT_QUEUE_CONFIG = DEFAULT_QUEUE_CONFIG;
 exports.DIContainer = DIContainer;
 exports.DI_TOKENS = DI_TOKENS;
 exports.DailyReportMapper = DailyReportMapper;
@@ -9852,8 +7419,6 @@ exports.NotificationRepositoryImpl = NotificationRepositoryImpl;
 exports.NotificationSchema = NotificationSchema;
 exports.NotificationScopeSchema = NotificationScopeSchema;
 exports.NotificationService = NotificationService;
-exports.OfflineManager = OfflineManager;
-exports.OperationQueue = OperationQueue;
 exports.PEMStatusOfflineRequestSchema = PEMStatusOfflineRequestSchema;
 exports.PEMStatusSchema = PEMStatusSchema;
 exports.PEM_STATUS_OPTIONS = PEM_STATUS_OPTIONS;
@@ -9888,7 +7453,6 @@ exports.SupplierCreateInputSchema = SupplierCreateInputSchema;
 exports.SupplierMapper = SupplierMapper;
 exports.SupplierRepositoryImpl = SupplierRepositoryImpl;
 exports.SupplierUpdateInputSchema = SupplierUpdateInputSchema;
-exports.SyncManager = SyncManager;
 exports.TelemetryMapper = TelemetryMapper;
 exports.TelemetryMerchantSchema = TelemetryMerchantSchema;
 exports.TelemetryRepositoryImpl = TelemetryRepositoryImpl;