cuoral-ionic 0.0.1 → 0.0.2

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/intelligence.d.ts

@@ -0,0 +1,66 @@
+export declare class CuoralIntelligence {
+    private config;
+    private queues;
+    private batchTimers;
+    private sessionId;
+    private isInitialized;
+    private lastPageViewTimestamp;
+    private lastPageViewScreen;
+    private pendingEvents;
+    private originalFetch;
+    private originalXMLHttpRequest;
+    constructor(sessionId: string);
+    /**
+     * Initialize intelligence tracking
+     */
+    init(): void;
+    /**
+     * Track a page/screen view
+     */
+    trackPageView(screen: string, metadata?: any): void;
+    /**
+     * Track a console error manually
+     */
+    trackError(message: string, stackTrace?: string, metadata?: any): void;
+    /**
+     * Flush all queued events immediately
+     */
+    flush(): void;
+    /**
+     * Destroy and cleanup
+     */
+    destroy(): void;
+    /**
+     * Setup console error listener
+     */
+    private setupConsoleErrorListener;
+    /**
+     * Setup network monitoring
+     */
+    private setupNetworkMonitoring;
+    /**
+     * Setup app state listener
+     */
+    private setupAppStateListener;
+    /**
+     * Enqueue an event
+     */
+    private enqueueEvent;
+    /**
+     * Flush a specific queue
+     */
+    private flushQueue;
+    /**
+     * Send data to backend
+     */
+    private sendToBackend;
+    /**
+     * Flush pending events
+     */
+    private flushPendingEvents;
+    /**
+     * Setup native error capture for Android/iOS crashes
+     */
+    private setupNativeErrorCapture;
+}
+//# sourceMappingURL=intelligence.d.ts.map

package/dist/intelligence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.d.ts","sourceRoot":"","sources":["../src/intelligence.ts"],"names":[],"mappings":"AAsDA,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CASZ;IAEF,OAAO,CAAC,MAAM,CAKZ;IAEF,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,qBAAqB,CAAc;IAC3C,OAAO,CAAC,kBAAkB,CAAM;IAChC,OAAO,CAAC,aAAa,CAAa;IAGlC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,sBAAsB,CAAa;gBAE/B,SAAS,EAAE,MAAM;IAI7B;;OAEG;IACI,IAAI,IAAI,IAAI;IAenB;;OAEG;IACI,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAc1D;;OAEG;IACI,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAS7E;;OAEG;IACI,KAAK,IAAI,IAAI;IAMpB;;OAEG;IACI,OAAO,IAAI,IAAI;IA4BtB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAoFjC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA8H9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAwCpB;;OAEG;IACH,OAAO,CAAC,UAAU;IAoFlB;;OAEG;YACW,aAAa;IAiC3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAgBhC"}

package/dist/intelligence.js

@@ -0,0 +1,508 @@
+import { Capacitor } from '@capacitor/core';
+import { registerPlugin } from '@capacitor/core';
+// Register the Cuoral plugin for native error capture
+const CuoralPlugin = registerPlugin('CuoralPlugin');
+export class CuoralIntelligence {
+    constructor(sessionId) {
+        this.config = {
+            consoleErrorBackendUrl: 'https://api.cuoral.com/customer-intelligence/console-error',
+            pageViewBackendUrl: 'https://api.cuoral.com/customer-intelligence/page-view',
+            apiResponseBackendUrl: 'https://api.cuoral.com/customer-intelligence/api-response',
+            batchSize: 10,
+            batchInterval: 2000,
+            maxQueueSize: 30,
+            retryAttempts: 1,
+            retryDelay: 2000,
+        };
+        this.queues = {
+            console_error: [],
+            unhandled_error: [],
+            page_view: [],
+            api_call: [],
+        };
+        this.batchTimers = {};
+        this.sessionId = null;
+        this.isInitialized = false;
+        this.lastPageViewTimestamp = Date.now();
+        this.lastPageViewScreen = '';
+        this.pendingEvents = [];
+        // Network monitoring state
+        this.originalFetch = null;
+        this.originalXMLHttpRequest = null;
+        this.sessionId = sessionId;
+    }
+    /**
+     * Initialize intelligence tracking
+     */
+    init() {
+        if (this.isInitialized) {
+            console.warn('[Cuoral Intelligence] Already initialized');
+            return;
+        }
+        this.setupConsoleErrorListener();
+        this.setupNetworkMonitoring();
+        this.setupAppStateListener();
+        this.setupNativeErrorCapture();
+        this.isInitialized = true;
+        this.flushPendingEvents();
+    }
+    /**
+     * Track a page/screen view
+     */
+    trackPageView(screen, metadata) {
+        const duration = Date.now() - this.lastPageViewTimestamp;
+        this.enqueueEvent('page_view', {
+            screen,
+            referrer: this.lastPageViewScreen,
+            duration,
+            metadata: metadata || {},
+        });
+        this.lastPageViewTimestamp = Date.now();
+        this.lastPageViewScreen = screen;
+    }
+    /**
+     * Track a console error manually
+     */
+    trackError(message, stackTrace, metadata) {
+        this.enqueueEvent('console_error', {
+            message,
+            stack_trace: stackTrace || 'No stack trace available',
+            log_level: 'error',
+            metadata: metadata || {},
+        });
+    }
+    /**
+     * Flush all queued events immediately
+     */
+    flush() {
+        Object.keys(this.queues).forEach((type) => {
+            this.flushQueue(type);
+        });
+    }
+    /**
+     * Destroy and cleanup
+     */
+    destroy() {
+        // Clear all timers
+        Object.keys(this.batchTimers).forEach((type) => {
+            if (this.batchTimers[type]) {
+                clearTimeout(this.batchTimers[type]);
+                delete this.batchTimers[type];
+            }
+        });
+        // Restore original functions
+        if (this.originalFetch) {
+            window.fetch = this.originalFetch;
+            this.originalFetch = null;
+        }
+        if (this.originalXMLHttpRequest) {
+            window.XMLHttpRequest = this.originalXMLHttpRequest;
+            this.originalXMLHttpRequest = null;
+        }
+        // Clear queues
+        Object.keys(this.queues).forEach((type) => {
+            this.queues[type] = [];
+        });
+        this.isInitialized = false;
+    }
+    /**
+     * Setup console error listener
+     */
+    setupConsoleErrorListener() {
+        // Override console.error
+        const originalConsoleError = console.error;
+        console.error = (...args) => {
+            originalConsoleError.apply(console, args);
+            try {
+                // Try to find an Error object in arguments to get real stack trace
+                let stack = '';
+                let message = '';
+                // Check each argument for error information
+                for (const arg of args) {
+                    if (arg instanceof Error) {
+                        stack = arg.stack || '';
+                        message = arg.message;
+                        break;
+                    }
+                    else if (arg && typeof arg === 'object') {
+                        if (arg.stack && typeof arg.stack === 'string') {
+                            stack = arg.stack;
+                            message = arg.message || arg.toString();
+                            break;
+                        }
+                        if (arg.rejection && arg.rejection instanceof Error) {
+                            stack = arg.rejection.stack || '';
+                            message = arg.rejection.message;
+                            break;
+                        }
+                        if (arg.error instanceof Error) {
+                            stack = arg.error.stack || '';
+                            message = arg.error.message;
+                            break;
+                        }
+                    }
+                }
+                // If no stack found, generate one from current context
+                // Note: Angular's ErrorHandler doesn't pass Error objects, so this will
+                // capture the console.error call stack, not the original error stack.
+                // For better error tracking, use source maps or test with unminified builds.
+                if (!stack) {
+                    const error = new Error();
+                    stack = error.stack || 'No stack trace available';
+                    message = args.map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ');
+                }
+                this.enqueueEvent('console_error', {
+                    message: message || 'Console error',
+                    stack_trace: stack,
+                    log_level: 'error',
+                    metadata: {},
+                });
+            }
+            catch (err) {
+                // Silently fail
+            }
+        };
+        // Global error handler
+        window.onerror = (message, source, lineno, colno, error) => {
+            try {
+                this.enqueueEvent('unhandled_error', {
+                    message: String(message),
+                    source: source || 'unknown',
+                    lineno: lineno || 0,
+                    colno: colno || 0,
+                    stack_trace: error?.stack || 'No stack trace available',
+                    log_level: 'error',
+                });
+            }
+            catch (err) {
+                // Silently fail
+            }
+            return false;
+        };
+        // Unhandled promise rejection
+        window.addEventListener('unhandledrejection', (event) => {
+            this.enqueueEvent('unhandled_error', {
+                message: event.reason instanceof Error ? event.reason.message : String(event.reason),
+                stack_trace: event.reason?.stack || 'No stack trace available',
+                log_level: 'error',
+            });
+        });
+    }
+    /**
+     * Setup network monitoring
+     */
+    setupNetworkMonitoring() {
+        // Store original fetch
+        if (!this.originalFetch) {
+            this.originalFetch = window.fetch;
+        }
+        // Override fetch
+        window.fetch = async (...args) => {
+            const url = args[0] instanceof Request ? args[0].url : args[0];
+            const method = args[0] instanceof Request && args[0].method
+                ? args[0].method
+                : args[1]?.method || 'GET';
+            const startTime = Date.now();
+            try {
+                const response = await this.originalFetch.apply(window, args);
+                const duration = Date.now() - startTime;
+                const status = response.status;
+                // Only track errors (4xx, 5xx)
+                if (status >= 400) {
+                    const responseClone = response.clone();
+                    try {
+                        const text = await responseClone.text();
+                        let responseData = null;
+                        try {
+                            const truncated = text.length > 5000 ? text.substring(0, 5000) + '...' : text;
+                            responseData = JSON.parse(truncated);
+                        }
+                        catch (e) {
+                            responseData = text.length > 5000 ? text.substring(0, 5000) + '...' : text;
+                        }
+                        this.enqueueEvent('api_call', {
+                            method,
+                            url,
+                            status_code: status,
+                            response_data: responseData,
+                            duration,
+                        });
+                    }
+                    catch (err) {
+                        this.enqueueEvent('api_call', {
+                            method,
+                            url,
+                            status_code: status,
+                            duration,
+                            error: 'Failed to read response body',
+                        });
+                    }
+                }
+                return response;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                this.enqueueEvent('api_call', {
+                    method,
+                    url,
+                    status_code: 0,
+                    response_data: error.message || 'Network Error',
+                    duration,
+                    error: error.message || 'Network Error',
+                });
+                throw error;
+            }
+        };
+        // Store original XMLHttpRequest
+        if (!this.originalXMLHttpRequest && window.XMLHttpRequest) {
+            this.originalXMLHttpRequest = window.XMLHttpRequest;
+        }
+        // Override XMLHttpRequest
+        const originalOpen = XMLHttpRequest.prototype.open;
+        const originalSend = XMLHttpRequest.prototype.send;
+        XMLHttpRequest.prototype.open = function (method, url) {
+            this._cuoralMethod = method;
+            this._cuoralUrl = url;
+            return originalOpen.apply(this, arguments);
+        };
+        XMLHttpRequest.prototype.send = function () {
+            const startTime = Date.now();
+            const xhr = this;
+            const loadendHandler = () => {
+                try {
+                    const status = xhr.status;
+                    const duration = Date.now() - startTime;
+                    // Only track errors (4xx, 5xx)
+                    if (status >= 400) {
+                        let responseData = null;
+                        try {
+                            const responseText = xhr.responseText || '';
+                            const truncated = responseText.length > 5000
+                                ? responseText.substring(0, 5000) + '...'
+                                : responseText;
+                            responseData = truncated ? JSON.parse(truncated) : truncated;
+                        }
+                        catch (e) {
+                            const responseText = xhr.responseText || '';
+                            responseData = responseText.length > 5000
+                                ? responseText.substring(0, 5000) + '...'
+                                : responseText;
+                        }
+                        window._cuoralIntelligence?.enqueueEvent('api_call', {
+                            method: xhr._cuoralMethod,
+                            url: xhr._cuoralUrl,
+                            status_code: status,
+                            response_data: responseData,
+                            duration,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Silently fail
+                }
+            };
+            this.addEventListener('loadend', loadendHandler, { once: true });
+            return originalSend.apply(this, arguments);
+        };
+        // Store reference for XMLHttpRequest monitoring
+        window._cuoralIntelligence = this;
+    }
+    /**
+     * Setup app state listener
+     */
+    setupAppStateListener() {
+        // Listen for app going to background
+        window.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                this.flush();
+            }
+        });
+        // Listen for app pause (Capacitor)
+        if (Capacitor.isNativePlatform()) {
+            window.addEventListener('pause', () => {
+                this.flush();
+            });
+        }
+    }
+    /**
+     * Enqueue an event
+     */
+    enqueueEvent(type, data) {
+        const queue = this.queues[type];
+        if (!queue) {
+            return;
+        }
+        // Don't track successful API calls (2xx, 3xx)
+        if (type === 'api_call' && data.status_code >= 200 && data.status_code < 400) {
+            return;
+        }
+        // Limit queue size
+        if (queue.length >= this.config.maxQueueSize) {
+            queue.shift();
+        }
+        const event = {
+            event_type: type,
+            timestamp: Date.now(),
+            session_id: this.sessionId || '',
+            user_agent: navigator.userAgent,
+            url: window.location.href,
+            data,
+        };
+        queue.push(event);
+        // Flush immediately for critical errors
+        const shouldFlushImmediately = type === 'api_call' && (data.status_code === 0 || data.status_code >= 400);
+        if (shouldFlushImmediately || queue.length >= this.config.batchSize) {
+            this.flushQueue(type);
+        }
+        else if (!this.batchTimers[type]) {
+            this.batchTimers[type] = setTimeout(() => this.flushQueue(type), this.config.batchInterval);
+        }
+    }
+    /**
+     * Flush a specific queue
+     */
+    flushQueue(eventType, useBeacon = false) {
+        const queue = this.queues[eventType];
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        // Clear timer
+        if (this.batchTimers[eventType]) {
+            clearTimeout(this.batchTimers[eventType]);
+            delete this.batchTimers[eventType];
+        }
+        const eventsToProcess = [...queue];
+        this.queues[eventType] = [];
+        let backendUrl;
+        let transformedPayload;
+        if (eventType === 'console_error' || eventType === 'unhandled_error') {
+            backendUrl = this.config.consoleErrorBackendUrl;
+            transformedPayload = eventsToProcess.map((event) => ({
+                message: event.data.message,
+                stack_trace: event.data.stack_trace,
+                log_level: 'error',
+                url: event.url,
+                session_id: event.session_id,
+                source: 'mobile',
+                console_metadata: event.data.metadata || {},
+            }));
+        }
+        else if (eventType === 'page_view') {
+            backendUrl = this.config.pageViewBackendUrl;
+            transformedPayload = eventsToProcess.map((event) => ({
+                session_id: event.session_id,
+                url: event.data.screen,
+                referrer: event.data.referrer,
+                user_agent: event.user_agent,
+                source: 'mobile',
+                page_metadata: {
+                    duration: event.data.duration,
+                    screen: event.data.screen,
+                    ...event.data.metadata,
+                },
+                timestamp: new Date(event.timestamp).toISOString(),
+            }));
+        }
+        else if (eventType === 'api_call') {
+            backendUrl = this.config.apiResponseBackendUrl;
+            transformedPayload = eventsToProcess
+                .map((event) => {
+                let responseBody = event.data.response_data;
+                if (typeof responseBody === 'string') {
+                    try {
+                        responseBody = JSON.parse(responseBody);
+                    }
+                    catch (e) {
+                        responseBody = { raw_text: responseBody };
+                    }
+                }
+                else if (responseBody === null || typeof responseBody === 'undefined') {
+                    responseBody = {};
+                }
+                return {
+                    url: event.data.url,
+                    method: event.data.method,
+                    status_code: event.data.status_code,
+                    response_body: responseBody,
+                    session_id: event.session_id,
+                    source: 'mobile',
+                    api_metadata: {
+                        duration: event.data.duration,
+                        error: event.data.error || null,
+                    },
+                };
+            })
+                .filter((item) => item !== null && item !== undefined);
+        }
+        else {
+            return;
+        }
+        const filteredPayload = transformedPayload.filter((item) => item !== null && item !== undefined);
+        if (backendUrl && filteredPayload.length > 0) {
+            this.sendToBackend(backendUrl, filteredPayload, useBeacon);
+        }
+    }
+    /**
+     * Send data to backend
+     */
+    async sendToBackend(url, payload, useBeacon = false, retryCount = 0) {
+        if (!this.sessionId) {
+            this.pendingEvents.push({ url, payload, useBeacon });
+            return;
+        }
+        if (!navigator.onLine) {
+            return;
+        }
+        const data = JSON.stringify(payload);
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: data,
+                keepalive: useBeacon,
+            });
+            if (!response.ok && retryCount < this.config.retryAttempts) {
+                setTimeout(() => {
+                    this.sendToBackend(url, payload, false, retryCount + 1);
+                }, this.config.retryDelay);
+            }
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Flush pending events
+     */
+    flushPendingEvents() {
+        if (this.pendingEvents.length > 0) {
+            const pending = [...this.pendingEvents];
+            this.pendingEvents = [];
+            pending.forEach(({ url, payload, useBeacon }) => {
+                this.sendToBackend(url, payload, useBeacon);
+            });
+        }
+    }
+    /**
+     * Setup native error capture for Android/iOS crashes
+     */
+    setupNativeErrorCapture() {
+        try {
+            // Only run on native platforms and if we have a session ID
+            if (Capacitor.isNativePlatform() && this.sessionId) {
+                CuoralPlugin.setupNativeErrorCapture({
+                    backendUrl: this.config.consoleErrorBackendUrl,
+                    sessionId: this.sessionId,
+                }).catch(() => {
+                    // Silently fail - native error capture optional
+                });
+            }
+        }
+        catch (error) {
+            // Silently fail if plugin is not available
+        }
+    }
+}

package/dist/plugin.d.ts

@@ -39,7 +39,7 @@ export interface CuoralPluginInterface {
     }>;
 }
 /**
- * Register the Capacitor plugin
+ * Register the Capacitor plugin (mobile only - iOS and Android)
  */
 declare const CuoralPlugin: CuoralPluginInterface;
 export { CuoralPlugin };

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAE1E;;OAEG;IACH,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAErF;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IAE7C;;OAEG;IACH,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAErE;;OAEG;IACH,oBAAoB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAExD;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,uBAEhB,CAAC;AAEH,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAEpC;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IA4ClE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAwC/E;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAqBjF;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IAIzC;;OAEG;IACH,OAAO,CAAC,WAAW;CAKpB"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAE1E;;OAEG;IACH,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAErF;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IAE7C;;OAEG;IACH,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAErE;;OAEG;IACH,oBAAoB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAExD;;OAEG;IACH,kBAAkB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,QAAA,MAAM,YAAY,uBAAwD,CAAC;AAE3E,OAAO,EAAE,YAAY,EAAE,CAAC;AAExB;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAEpC;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAyDlE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAiD/E;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAqBjF;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IAIzC;;OAEG;IACH,OAAO,CAAC,WAAW;CAKpB"}

package/dist/plugin.js

@@ -1,11 +1,9 @@
 import { registerPlugin } from '@capacitor/core';
 import { CuoralMessageType, } from './types';
 /**
- * Register the Capacitor plugin
+ * Register the Capacitor plugin (mobile only - iOS and Android)
  */
-const CuoralPlugin = registerPlugin('CuoralPlugin', {
-    web: () => import('./web').then(m => new m.CuoralPluginWeb()),
-});
+const CuoralPlugin = registerPlugin('CuoralPlugin');
 export { CuoralPlugin };
 /**
  * High-level API for easier integration
@@ -45,10 +43,21 @@ export class CuoralRecorder {
                     payload: { timestamp: this.recordingStartTime },
                 });
             }
+            else {
+                // Recording failed - reset state and notify widget
+                this.isRecording = false;
+                this.recordingStartTime = undefined;
+                this.postMessage({
+                    type: CuoralMessageType.RECORDING_ERROR,
+                    payload: { error: 'Failed to start recording' },
+                });
+            }
             return result.success;
         }
         catch (error) {
-            console.error('[Cuoral] Failed to start recording:', error);
+            // Exception occurred - reset state and notify widget
+            this.isRecording = false;
+            this.recordingStartTime = undefined;
             this.postMessage({
                 type: CuoralMessageType.RECORDING_ERROR,
                 payload: { error: error.message },
@@ -62,7 +71,11 @@ export class CuoralRecorder {
     async stopRecording() {
         try {
             if (!this.isRecording) {
-                console.warn('[Cuoral] Not recording');
+                // Send error message to widget so it can exit "stopping" state
+                this.postMessage({
+                    type: CuoralMessageType.RECORDING_ERROR,
+                    payload: { error: 'Not recording' },
+                });
                 return null;
             }
             const result = await CuoralPlugin.stopRecording();
@@ -84,6 +97,11 @@ export class CuoralRecorder {
                     duration: result.duration || duration,
                 };
             }
+            // If result.success is false, send error to widget
+            this.postMessage({
+                type: CuoralMessageType.RECORDING_ERROR,
+                payload: { error: 'Failed to stop recording' },
+            });
             return null;
         }
         catch (error) {

package/dist/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,eAAgB,SAAQ,SAAU,YAAW,qBAAqB;IAC7E,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAE9B,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IA4BzE,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IA2BpF,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC;IAS5C,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC;IA6CpE,oBAAoB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAKvD,kBAAkB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAI1D"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,cAAc,EACf,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,eAAgB,SAAQ,SAAU,YAAW,qBAAqB;IAC7E,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAS;IAE9B,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IA0BzE,aAAa,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAyBpF,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC;IAS5C,cAAc,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC;IA2CpE,oBAAoB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IAKvD,kBAAkB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAI1D"}