react-native-inapp-inspector 1.1.25 → 1.1.26

package/dist/commonjs/customHooks/crashHandler.js

@@ -0,0 +1,681 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGlobalCrashHandler = exports.exportCrashReport = exports.simulateTestCrash = exports.recordCustomCrash = exports.handleInterceptedCrash = exports.emitCrashEvent = exports.subscribeCrashEvents = exports.clearCrashRecords = exports.getCrashRecords = exports.computeCrashFingerprint = exports.parseCrashStackTrace = exports.getCrashBreadcrumbs = exports.clearCrashBreadcrumbs = exports.recordUserActionBreadcrumb = exports.recordReduxBreadcrumb = exports.recordNetworkBreadcrumb = exports.recordNavigationBreadcrumb = exports.addCrashBreadcrumb = exports.setMaxCrashLogsLimit = exports.CrashExportFormat = void 0;
+const react_native_1 = require("react-native");
+const enums_1 = require("../types/enums");
+Object.defineProperty(exports, "CrashExportFormat", { enumerable: true, get: function () { return enums_1.CrashExportFormat; } });
+const consoleLogger_1 = require("./consoleLogger");
+const i18n_1 = require("../i18n");
+let crashListeners = [];
+let isCrashHandlerInitialized = false;
+let lastHandledErrorTimestamp = 0;
+let crashRecordsStore = [];
+let breadcrumbsStore = [];
+const MAX_BREADCRUMBS = 50;
+let maxStoredCrashes = 100;
+const appStartTime = Date.now();
+// ─── BREADCRUMB MANAGERS ───────────────────────────────────────────────────────
+const setMaxCrashLogsLimit = (max) => {
+    maxStoredCrashes = Math.max(10, max);
+    if (crashRecordsStore.length > maxStoredCrashes) {
+        crashRecordsStore = crashRecordsStore.slice(0, maxStoredCrashes);
+    }
+};
+exports.setMaxCrashLogsLimit = setMaxCrashLogsLimit;
+const addCrashBreadcrumb = (type, message, data) => {
+    try {
+        const entry = {
+            type,
+            message,
+            timestamp: Date.now(),
+            data,
+        };
+        breadcrumbsStore.unshift(entry);
+        if (breadcrumbsStore.length > MAX_BREADCRUMBS) {
+            breadcrumbsStore = breadcrumbsStore.slice(0, MAX_BREADCRUMBS);
+        }
+    }
+    catch { }
+};
+exports.addCrashBreadcrumb = addCrashBreadcrumb;
+const recordNavigationBreadcrumb = (fromRoute, toRoute) => {
+    (0, exports.addCrashBreadcrumb)('navigation', (0, i18n_1.t)('crash.breadcrumbNavigation', { from: fromRoute || '/', to: toRoute || '/' }), {
+        from: fromRoute,
+        to: toRoute,
+    });
+};
+exports.recordNavigationBreadcrumb = recordNavigationBreadcrumb;
+const recordNetworkBreadcrumb = (url, method, status, duration) => {
+    const statusStr = status != null ? ` [${status}]` : '';
+    const durStr = duration != null ? ` (${Math.round(duration)}ms)` : '';
+    (0, exports.addCrashBreadcrumb)('network', `${method.toUpperCase()} ${url}${statusStr}${durStr}`, {
+        url,
+        method,
+        status,
+        duration,
+    });
+};
+exports.recordNetworkBreadcrumb = recordNetworkBreadcrumb;
+const recordReduxBreadcrumb = (actionType, payload) => {
+    (0, exports.addCrashBreadcrumb)('redux', (0, i18n_1.t)('crash.breadcrumbAction', { actionType }), {
+        type: actionType,
+        payloadSummary: typeof payload === 'object' && payload !== null
+            ? Object.keys(payload)
+            : typeof payload,
+    });
+};
+exports.recordReduxBreadcrumb = recordReduxBreadcrumb;
+const recordUserActionBreadcrumb = (action, metadata) => {
+    (0, exports.addCrashBreadcrumb)('user', action, metadata);
+};
+exports.recordUserActionBreadcrumb = recordUserActionBreadcrumb;
+const clearCrashBreadcrumbs = () => {
+    breadcrumbsStore = [];
+};
+exports.clearCrashBreadcrumbs = clearCrashBreadcrumbs;
+const getCrashBreadcrumbs = () => {
+    return [...breadcrumbsStore];
+};
+exports.getCrashBreadcrumbs = getCrashBreadcrumbs;
+// ─── STACK TRACE PARSING & INTELLIGENT SOURCE DETECTION ───────────────────────
+/**
+ * Intelligent stack trace parser with multi-engine support:
+ * - Hermes bytecode & source maps
+ * - Android Java / Kotlin native frames
+ * - iOS Objective-C / Swift symbols
+ * - JavaScript standard V8 & SpiderMonkey
+ */
+const parseCrashStackTrace = (stack) => {
+    if (!stack || typeof stack !== 'string')
+        return [];
+    const lines = stack.split('\n');
+    const frames = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Filter out internal wrapper noise
+        if (trimmed.includes('crashHandler.ts') ||
+            trimmed.includes('handleInterceptedCrash') ||
+            trimmed.includes('addLogFromCrash') ||
+            trimmed.includes('setupGlobalCrashHandler')) {
+            continue;
+        }
+        // Pattern 1: iOS/Hermes format: method@file:line:column or method@url:line:col
+        const iosMatch = trimmed.match(/^([^@]+)@(.*):(\d+):(\d+)$/);
+        if (iosMatch) {
+            const [, method, file, lineNum, colNum] = iosMatch;
+            const cleanFile = file.split('?')[0].split('/').pop() || file;
+            const isAppCode = !file.includes('node_modules') &&
+                !file.includes('react-native') &&
+                !file.includes('react-dom') &&
+                !file.includes('hermes') &&
+                !file.includes('internal');
+            frames.push({
+                method: method.trim(),
+                file: cleanFile,
+                lineNumber: parseInt(lineNum, 10),
+                column: parseInt(colNum, 10),
+                raw: trimmed,
+                isAppCode,
+            });
+            continue;
+        }
+        // Pattern 2: V8/Android JS format: at method (file:line:column)
+        const androidMatch = trimmed.match(/^at\s+(.+)\s+\((.+):(\d+):(\d+)\)$/);
+        if (androidMatch) {
+            const [, method, file, lineNum, colNum] = androidMatch;
+            const cleanFile = file.split('?')[0].split('/').pop() || file;
+            const isAppCode = !file.includes('node_modules') &&
+                !file.includes('react-native') &&
+                !file.includes('react-dom') &&
+                !file.includes('internal');
+            frames.push({
+                method: method.trim(),
+                file: cleanFile,
+                lineNumber: parseInt(lineNum, 10),
+                column: parseInt(colNum, 10),
+                raw: trimmed,
+                isAppCode,
+            });
+            continue;
+        }
+        // Pattern 3: Simple at file:line:column
+        const simpleMatch = trimmed.match(/^at\s+(.+):(\d+):(\d+)$/);
+        if (simpleMatch) {
+            const [, file, lineNum, colNum] = simpleMatch;
+            const cleanFile = file.split('?')[0].split('/').pop() || file;
+            const isAppCode = !file.includes('node_modules') && !file.includes('react-native');
+            frames.push({
+                method: '<anonymous>',
+                file: cleanFile,
+                lineNumber: parseInt(lineNum, 10),
+                column: parseInt(colNum, 10),
+                raw: trimmed,
+                isAppCode,
+            });
+            continue;
+        }
+        // Pattern 4: Java / Android Native Frame: at com.pkg.Class.method(Class.java:123)
+        const javaMatch = trimmed.match(/^at\s+([a-zA-Z0-9_$.]+)\(([a-zA-Z0-9_$]+\.java):(\d+)\)$/);
+        if (javaMatch) {
+            const [, methodPath, fileName, lineNum] = javaMatch;
+            const isAppCode = !methodPath.startsWith('com.facebook.react') &&
+                !methodPath.startsWith('android.');
+            frames.push({
+                method: methodPath,
+                file: fileName,
+                lineNumber: parseInt(lineNum, 10),
+                column: 0,
+                raw: trimmed,
+                isAppCode,
+            });
+            continue;
+        }
+        // Pattern 5: iOS Mach-O Symbol: 0   AppName   0x000000010... -[ViewController method] + 48
+        const machOMatch = trimmed.match(/^\d+\s+([^\s]+)\s+(0x[0-9a-fA-F]+)\s+(.+)$/);
+        if (machOMatch) {
+            const [, binaryName, address, symbol] = machOMatch;
+            const isAppCode = !binaryName.startsWith('lib') &&
+                !binaryName.startsWith('Core') &&
+                !binaryName.startsWith('React');
+            frames.push({
+                method: symbol,
+                file: binaryName,
+                lineNumber: 0,
+                column: 0,
+                raw: trimmed,
+                isAppCode,
+            });
+            continue;
+        }
+        // Pattern 6: Fallback for generic frame lines
+        frames.push({
+            method: trimmed.startsWith('at ') ? trimmed.slice(3) : trimmed,
+            file: 'runtime',
+            lineNumber: 0,
+            column: 0,
+            raw: trimmed,
+            isAppCode: false,
+        });
+    }
+    return frames;
+};
+exports.parseCrashStackTrace = parseCrashStackTrace;
+// ─── DIAGNOSTICS & SYSTEM METRICS ─────────────────────────────────────────────
+const getMemoryDiagnostics = () => {
+    try {
+        const performance = globalThis.performance;
+        if (performance && performance.memory) {
+            return {
+                usedJSHeapSize: Math.round(performance.memory.usedJSHeapSize / (1024 * 1024)),
+                totalJSHeapSize: Math.round(performance.memory.totalJSHeapSize / (1024 * 1024)),
+            };
+        }
+    }
+    catch { }
+    return undefined;
+};
+const getScreenDimensions = () => {
+    try {
+        const window = react_native_1.Dimensions.get('window');
+        return `${Math.round(window.width)}x${Math.round(window.height)} (${window.scale}x)`;
+    }
+    catch {
+        return (0, i18n_1.t)('crash.unknown');
+    }
+};
+/**
+ * Computes a unique fingerprint signature to group recurring crash occurrences.
+ */
+const computeCrashFingerprint = (crash) => {
+    const type = crash.type || 'js';
+    const name = crash.name || 'Error';
+    const topFrame = crash.parsedStack && crash.parsedStack.length > 0
+        ? crash.parsedStack[0]
+        : null;
+    const location = topFrame
+        ? `${topFrame.file}:${topFrame.lineNumber}`
+        : 'unknown';
+    return `${type}_${name}_${location}`;
+};
+exports.computeCrashFingerprint = computeCrashFingerprint;
+// ─── CRASH RECORD MANAGEMENT & INTERCEPTION ───────────────────────────────────
+const getCrashRecords = () => {
+    return [...crashRecordsStore];
+};
+exports.getCrashRecords = getCrashRecords;
+const clearCrashRecords = () => {
+    crashRecordsStore = [];
+    (0, exports.emitCrashEvent)({
+        error: null,
+        message: '__CLEARED__',
+        timestamp: Date.now(),
+    });
+};
+exports.clearCrashRecords = clearCrashRecords;
+const subscribeCrashEvents = (listener) => {
+    crashListeners.push(listener);
+    return () => {
+        crashListeners = crashListeners.filter(l => l !== listener);
+    };
+};
+exports.subscribeCrashEvents = subscribeCrashEvents;
+const emitCrashEvent = (payload) => {
+    if (payload.message !== '__CLEARED__') {
+        const now = Date.now();
+        // Throttle duplicate rapid crash emissions within 250ms
+        if (now - lastHandledErrorTimestamp < 250) {
+            return;
+        }
+        lastHandledErrorTimestamp = now;
+    }
+    crashListeners.forEach(listener => {
+        try {
+            listener(payload);
+        }
+        catch { }
+    });
+};
+exports.emitCrashEvent = emitCrashEvent;
+/**
+ * Core exception interceptor. Ingests all forms of errors, parses call stacks,
+ * collects device telemetry, records breadcrumbs, and updates the store.
+ */
+const handleInterceptedCrash = (errorOrTitle, rawStack, isFatal = false, customType, componentStack) => {
+    try {
+        const errorObj = errorOrTitle instanceof Error
+            ? errorOrTitle
+            : typeof errorOrTitle === 'object' && errorOrTitle !== null
+                ? errorOrTitle
+                : new Error(String(errorOrTitle || (0, i18n_1.t)('crash.runtimeException')));
+        const rawMsg = errorObj.message ||
+            (typeof errorOrTitle === 'string' ? errorOrTitle : (0, i18n_1.t)('crash.runtimeException'));
+        let stackString = '';
+        if (typeof rawStack === 'string') {
+            stackString = rawStack;
+        }
+        else if (Array.isArray(rawStack)) {
+            stackString = rawStack
+                .map(f => `at ${f.methodName || '<anonymous>'} (${f.file || 'unknown'}:${f.lineNumber || 0}:${f.column || 0})`)
+                .join('\n');
+        }
+        else {
+            stackString = errorObj.stack || new Error().stack || '';
+        }
+        // Determine Crash Type
+        let inferredType = customType || enums_1.CrashType.Js;
+        const lowMsg = rawMsg.toLowerCase();
+        if (!customType) {
+            if (lowMsg.includes('native') ||
+                lowMsg.includes('sigsegv') ||
+                lowMsg.includes('nsrange') ||
+                lowMsg.includes('nullpointerexception') ||
+                lowMsg.includes('fatal signal')) {
+                inferredType = enums_1.CrashType.Native;
+            }
+            else if (lowMsg.includes('promise') ||
+                lowMsg.includes('unhandled rejection') ||
+                lowMsg.includes('unhandledrejection')) {
+                inferredType = enums_1.CrashType.Promise;
+            }
+            else if (lowMsg.includes('render') ||
+                lowMsg.includes('errorboundary') ||
+                componentStack) {
+                inferredType = enums_1.CrashType.Render;
+            }
+            else {
+                inferredType = enums_1.CrashType.Js;
+            }
+        }
+        const now = new Date();
+        const dateStr = now.toLocaleDateString();
+        const timeStr = now.toLocaleTimeString();
+        const parsedStack = (0, exports.parseCrashStackTrace)(stackString);
+        const log = (0, consoleLogger_1.addLogFromCrash)(errorObj, `[${isFatal ? (0, i18n_1.t)('crash.logFatalCrash') : (0, i18n_1.t)('crash.logUnhandledError')}] ${rawMsg}`, stackString, isFatal);
+        const isHermes = typeof globalThis.HermesInternal !== 'undefined';
+        const isFabric = typeof globalThis.nativeFabricUIManager !== 'undefined';
+        const crashRecord = {
+            id: `crash_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+            error: errorObj,
+            isFatal,
+            type: inferredType,
+            message: rawMsg,
+            name: errorObj.name || (isFatal ? (0, i18n_1.t)('crash.errorNameFatal') : (0, i18n_1.t)('crash.errorNameUnhandled')),
+            stack: stackString,
+            parsedStack,
+            componentStack: componentStack || undefined,
+            timestamp: Date.now(),
+            dateStr,
+            timeStr,
+            deviceInfo: {
+                platform: react_native_1.Platform.OS,
+                osVersion: String(react_native_1.Platform.Version),
+                rnVersion: react_native_1.Platform.constants?.reactNativeVersion
+                    ? `${react_native_1.Platform.constants.reactNativeVersion.major}.${react_native_1.Platform.constants.reactNativeVersion.minor}.${react_native_1.Platform.constants.reactNativeVersion.patch}`
+                    : (0, i18n_1.t)('crash.unknown'),
+                isHermes,
+                isFabric,
+                appState: react_native_1.AppState.currentState || 'active',
+            },
+            memoryInfo: getMemoryDiagnostics(),
+            breadcrumbs: [...breadcrumbsStore],
+            logId: log?.id,
+        };
+        crashRecordsStore.unshift(crashRecord);
+        if (crashRecordsStore.length > maxStoredCrashes) {
+            crashRecordsStore = crashRecordsStore.slice(0, maxStoredCrashes);
+        }
+        (0, exports.emitCrashEvent)({
+            error: errorObj,
+            isFatal,
+            message: `[${isFatal ? (0, i18n_1.t)('crash.logFatalCrash') : (0, i18n_1.t)('crash.logUnhandledError')}] ${rawMsg}`,
+            stack: stackString,
+            timestamp: Date.now(),
+            logId: log?.id,
+            crashRecord,
+        });
+        return crashRecord;
+    }
+    catch (err) {
+        const fallbackRecord = {
+            id: `crash_${Date.now()}`,
+            isFatal: true,
+            type: enums_1.CrashType.Js,
+            message: String(errorOrTitle || (0, i18n_1.t)('crash.unknownException')),
+            timestamp: Date.now(),
+            dateStr: new Date().toLocaleDateString(),
+            timeStr: new Date().toLocaleTimeString(),
+        };
+        return fallbackRecord;
+    }
+};
+exports.handleInterceptedCrash = handleInterceptedCrash;
+/**
+ * Manually report a caught error with custom metadata.
+ */
+const recordCustomCrash = (error, options) => {
+    return (0, exports.handleInterceptedCrash)(error, typeof error === 'object' ? error.stack : undefined, options?.isFatal ?? false, options?.type || enums_1.CrashType.Custom, options?.componentStack);
+};
+exports.recordCustomCrash = recordCustomCrash;
+/**
+ * Simulates a crash for developer testing without crashing the host app.
+ * Uses real runtime Error objects — no mocked file paths or fake stacks.
+ */
+const simulateTestCrash = (type = enums_1.CrashType.Js, customMessage, customStack) => {
+    const err = new Error(customMessage || _defaultSimMessage(type));
+    return (0, exports.handleInterceptedCrash)(type === enums_1.CrashType.Native ? err.message : err, customStack || err.stack, type === enums_1.CrashType.Native, type, type === enums_1.CrashType.Render ? _buildComponentStack() : undefined);
+};
+exports.simulateTestCrash = simulateTestCrash;
+/** Generates a generic error message per type — no fake references. */
+const _defaultSimMessage = (type) => {
+    switch (type) {
+        case 'native':
+            return (0, i18n_1.t)('crash.simNativeMessage');
+        case 'promise':
+            return (0, i18n_1.t)('crash.simPromiseMessage');
+        case 'render':
+            return (0, i18n_1.t)('crash.simRenderMessage');
+        default:
+            return (0, i18n_1.t)('crash.simJsMessage');
+    }
+};
+/** Builds a component stack from the real React tree if possible. */
+const _buildComponentStack = () => {
+    try {
+        const err = new Error();
+        if (err.stack) {
+            // Return the live stack as a pseudo component-stack
+            return err.stack
+                .split('\n')
+                .slice(1, 6)
+                .map(line => `    ${line.trim()}`)
+                .join('\n');
+        }
+    }
+    catch { }
+    return undefined;
+};
+// ─── EXPORT & REPORTING UTILITIES ─────────────────────────────────────────────
+/**
+ * Formats a crash into Text, Markdown, or JSON.
+ */
+const exportCrashReport = (crash, format = 'text') => {
+    if (format === 'json') {
+        return JSON.stringify(crash, null, 2);
+    }
+    const uptimeSec = Math.round((crash.timestamp - appStartTime) / 1000);
+    if (format === 'markdown') {
+        const lines = [];
+        lines.push(`## ${(0, i18n_1.t)('crash.mdReportTitle', { name: crash.name || 'Error' })}`);
+        lines.push(`> **${crash.message}**`);
+        lines.push('');
+        lines.push(`- **${(0, i18n_1.t)('crash.reportType')}** \`${crash.type.toUpperCase()}\``);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportFatal')}** \`${crash.isFatal
+            ? (0, i18n_1.t)('crash.mdSeverityFatal')
+            : (0, i18n_1.t)('crash.mdSeverityHandled')}\``);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportTimestamp')}** ${crash.dateStr} ${crash.timeStr}`);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportUptime')}** ${uptimeSec}s`);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportPlatform')}** ${crash.deviceInfo?.platform?.toUpperCase()} (v${crash.deviceInfo?.osVersion})`);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportReactNative')}** v${crash.deviceInfo?.rnVersion || 'N/A'}`);
+        lines.push(`- **${(0, i18n_1.t)('crash.jsEngine')}** ${crash.deviceInfo?.isHermes ? (0, i18n_1.t)('crash.hermesEngine') : (0, i18n_1.t)('crash.jsc')}`);
+        lines.push(`- **${(0, i18n_1.t)('crash.reportArchitecture')}** ${crash.deviceInfo?.isFabric
+            ? (0, i18n_1.t)('crash.reportFabricNew')
+            : (0, i18n_1.t)('crash.reportPaperLegacy')}`);
+        if (crash.memoryInfo) {
+            lines.push(`- **${(0, i18n_1.t)('crash.reportJsMemory')}** ${crash.memoryInfo.usedJSHeapSize} MB / ${crash.memoryInfo.totalJSHeapSize} MB`);
+        }
+        lines.push('');
+        lines.push(`### ${(0, i18n_1.t)('crash.mdStackTrace')}`);
+        lines.push('```');
+        lines.push(crash.stack || (0, i18n_1.t)('crash.reportNoStackTrace'));
+        lines.push('```');
+        if (crash.componentStack) {
+            lines.push('');
+            lines.push(`### ${(0, i18n_1.t)('crash.mdComponentHierarchy')}`);
+            lines.push('```');
+            lines.push(crash.componentStack);
+            lines.push('```');
+        }
+        if (crash.breadcrumbs && crash.breadcrumbs.length > 0) {
+            lines.push('');
+            lines.push(`### ${(0, i18n_1.t)('crash.mdRecentBreadcrumbs')}`);
+            crash.breadcrumbs.forEach(b => {
+                const time = new Date(b.timestamp).toLocaleTimeString();
+                lines.push(`- \`[${time}]\` **[${b.type.toUpperCase()}]** ${b.message}`);
+            });
+        }
+        return lines.join('\n');
+    }
+    // Standard Text format
+    const lines = [];
+    lines.push('====================================================');
+    lines.push(`               ${(0, i18n_1.t)('crash.reportTitle')}              `);
+    lines.push('====================================================');
+    lines.push(`${(0, i18n_1.t)('crash.reportErrorName')}    ${crash.name || 'Error'}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportMessage')}       ${crash.message}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportType')}          ${crash.type.toUpperCase()}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportFatal')}         ${crash.isFatal ? (0, i18n_1.t)('crash.reportFatalYes') : (0, i18n_1.t)('crash.reportFatalNo')}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportTimestamp')}     ${crash.dateStr} ${crash.timeStr} (${crash.timestamp})`);
+    lines.push(`${(0, i18n_1.t)('crash.reportUptime')}    ${(0, i18n_1.t)('crash.reportUptimeValue', {
+        seconds: uptimeSec,
+    })}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportPlatform')}      ${crash.deviceInfo?.platform?.toUpperCase()} (v${crash.deviceInfo?.osVersion})`);
+    lines.push(`${(0, i18n_1.t)('crash.reportReactNative')}  ${crash.deviceInfo?.rnVersion || 'N/A'}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportHermes')}        ${crash.deviceInfo?.isHermes
+        ? (0, i18n_1.t)('crash.reportEnabled')
+        : (0, i18n_1.t)('crash.reportDisabled')}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportArchitecture')}  ${crash.deviceInfo?.isFabric
+        ? (0, i18n_1.t)('crash.reportFabricNew')
+        : (0, i18n_1.t)('crash.reportPaperLegacy')}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportScreenSize')}   ${getScreenDimensions()}`);
+    lines.push(`${(0, i18n_1.t)('crash.reportAppState')}     ${crash.deviceInfo?.appState || 'active'}`);
+    if (crash.memoryInfo) {
+        lines.push(`${(0, i18n_1.t)('crash.reportJsMemory')}     ${crash.memoryInfo.usedJSHeapSize} MB / ${crash.memoryInfo.totalJSHeapSize} MB`);
+    }
+    lines.push('----------------------------------------------------');
+    lines.push(`${(0, i18n_1.t)('crash.reportStackTrace')}`);
+    lines.push(crash.stack || (0, i18n_1.t)('crash.reportNoStackTrace'));
+    if (crash.componentStack) {
+        lines.push('----------------------------------------------------');
+        lines.push(`${(0, i18n_1.t)('crash.reportComponentHierarchy')}`);
+        lines.push(crash.componentStack);
+    }
+    if (crash.breadcrumbs && crash.breadcrumbs.length > 0) {
+        lines.push('----------------------------------------------------');
+        lines.push(`${(0, i18n_1.t)('crash.reportRecentBreadcrumbs')}`);
+        crash.breadcrumbs.forEach(b => {
+            const time = new Date(b.timestamp).toLocaleTimeString();
+            lines.push(` [${time}] [${b.type.toUpperCase()}] ${b.message}`);
+        });
+    }
+    lines.push('====================================================');
+    return lines.join('\n');
+};
+exports.exportCrashReport = exportCrashReport;
+// ─── GLOBAL HANDLER INITIALIZATION ────────────────────────────────────────────
+/**
+ * Natively intercepts and prevents crashes, native RedBox dialogues,
+ * unhandled JS errors, and unhandled promise rejections.
+ */
+const setupGlobalCrashHandler = () => {
+    if (isCrashHandlerInitialized)
+        return;
+    isCrashHandlerInitialized = true;
+    // 1. Completely silence React Native LogBox & RedBox overlays
+    try {
+        if (react_native_1.LogBox && typeof react_native_1.LogBox.ignoreAllLogs === 'function') {
+            react_native_1.LogBox.ignoreAllLogs(true);
+        }
+    }
+    catch { }
+    try {
+        // @ts-ignore
+        const LogBoxData = require('react-native/Libraries/LogBox/Data/LogBoxData');
+        if (LogBoxData && typeof LogBoxData.setDisabled === 'function') {
+            LogBoxData.setDisabled(true);
+        }
+    }
+    catch { }
+    // 2. Intercept Native Module: NetworkInspectorModule (Android & iOS)
+    try {
+        const networkInspectorModule = react_native_1.NativeModules?.NetworkInspectorModule;
+        if (networkInspectorModule) {
+            if (typeof networkInspectorModule.enableNativeCrashProtection === 'function') {
+                networkInspectorModule.enableNativeCrashProtection();
+            }
+            const nativeEmitter = new react_native_1.NativeEventEmitter(networkInspectorModule);
+            nativeEmitter.addListener('onNativeCrash', (event) => {
+                const platform = event?.platform || react_native_1.Platform.OS;
+                const msg = `[${platform.toUpperCase()} ${(0, i18n_1.t)('crash.nativeCrashTitle')}] ${event?.message || (0, i18n_1.t)('crash.nativeUncaughtException')}`;
+                const stack = event?.stack || '';
+                (0, exports.handleInterceptedCrash)(msg, stack, true, 'native');
+            });
+        }
+    }
+    catch { }
+    // 3. Intercept Native ExceptionsManager & RedBox modules (Bridge & TurboModules)
+    try {
+        const tmReg = react_native_1.TurboModuleRegistry || globalThis.__turboModuleProxy;
+        const nativeExceptionsManager = react_native_1.NativeModules?.ExceptionsManager ||
+            (tmReg?.get ? tmReg.get('ExceptionsManager') : null);
+        if (nativeExceptionsManager) {
+            nativeExceptionsManager.reportFatalException = (title, stack, exceptionId) => {
+                (0, exports.handleInterceptedCrash)(title, stack, true, 'native');
+                try {
+                    if (typeof nativeExceptionsManager.dismissRedbox === 'function') {
+                        nativeExceptionsManager.dismissRedbox();
+                    }
+                }
+                catch { }
+            };
+            nativeExceptionsManager.reportSoftException = (title, stack, exceptionId) => {
+                (0, exports.handleInterceptedCrash)(title, stack, false, 'js');
+                try {
+                    if (typeof nativeExceptionsManager.dismissRedbox === 'function') {
+                        nativeExceptionsManager.dismissRedbox();
+                    }
+                }
+                catch { }
+            };
+            nativeExceptionsManager.reportException = (data) => {
+                const msg = data?.message || data?.title || (0, i18n_1.t)('crash.nativeException');
+                const stack = data?.stack || data?.rawStack;
+                (0, exports.handleInterceptedCrash)(msg, stack, data?.isFatal ?? true, 'js');
+                try {
+                    if (typeof nativeExceptionsManager.dismissRedbox === 'function') {
+                        nativeExceptionsManager.dismissRedbox();
+                    }
+                }
+                catch { }
+            };
+            nativeExceptionsManager.updateExceptionMessage = () => { };
+            try {
+                if (typeof nativeExceptionsManager.dismissRedbox === 'function') {
+                    nativeExceptionsManager.dismissRedbox();
+                }
+            }
+            catch { }
+        }
+        const nativeRedBox = react_native_1.NativeModules?.RedBox ||
+            react_native_1.NativeModules?.RCTRedBox ||
+            (tmReg?.get ? tmReg.get('RedBox') || tmReg.get('RCTRedBox') : null);
+        if (nativeRedBox) {
+            if (typeof nativeRedBox.showErrorMessage === 'function') {
+                nativeRedBox.showErrorMessage = () => { };
+            }
+            if (typeof nativeRedBox.showUserError === 'function') {
+                nativeRedBox.showUserError = () => { };
+            }
+            if (typeof nativeRedBox.dismiss === 'function') {
+                nativeRedBox.dismiss();
+            }
+        }
+    }
+    catch { }
+    // 4. Hook React Native ErrorUtils
+    try {
+        const globalObj = globalThis;
+        const errorUtils = globalObj.ErrorUtils;
+        if (errorUtils) {
+            if (typeof errorUtils.setGlobalHandler === 'function') {
+                errorUtils.setGlobalHandler((error, isFatal) => {
+                    (0, exports.handleInterceptedCrash)(error, error?.stack, isFatal ?? false, 'js');
+                    // Suppress calling default crashing handler to prevent termination & RedBox
+                });
+            }
+            if (typeof errorUtils.reportFatalError === 'function') {
+                errorUtils.reportFatalError = (error) => {
+                    (0, exports.handleInterceptedCrash)(error, error?.stack, true, 'js');
+                };
+            }
+            if (typeof errorUtils.reportError === 'function') {
+                errorUtils.reportError = (error) => {
+                    (0, exports.handleInterceptedCrash)(error, error?.stack, false, 'js');
+                };
+            }
+        }
+    }
+    catch { }
+    // 5. Hook global Promise unhandled rejections
+    try {
+        const globalObj = globalThis;
+        const handleUnhandledPromise = (eventOrError) => {
+            try {
+                const reason = eventOrError?.reason || eventOrError?.detail?.reason || eventOrError;
+                const message = reason?.message || String(reason || (0, i18n_1.t)('crash.unhandledPromiseRejection'));
+                const stack = reason?.stack || (eventOrError?.stack ?? new Error().stack);
+                (0, exports.handleInterceptedCrash)(reason, stack, false, 'promise');
+            }
+            catch { }
+        };
+        if (typeof globalObj.addEventListener === 'function') {
+            globalObj.addEventListener('unhandledrejection', handleUnhandledPromise);
+        }
+        if (typeof globalObj.onunhandledrejection !== 'undefined') {
+            globalObj.onunhandledrejection = handleUnhandledPromise;
+        }
+    }
+    catch { }
+};
+exports.setupGlobalCrashHandler = setupGlobalCrashHandler;