react-native-inapp-inspector 1.1.35 → 2.0.0

package/dist/esm/index.js

@@ -10,7 +10,8 @@ import { InspectorContext, animateNextLayout, } from './components/Inspector/Ins
 // Helpers
 import { formatDisplayUrl, getNavigationInfo, deduplicateLogs, getDomainColor, getEventCategory, } from './helpers';
 // #5 — settings persistence
-import { loadSettings, saveSettings, setCustomStorage, clearPersistedSettings, } from './helpers/settingsStore';
+import { loadSettings, saveSettings, setCustomStorage, clearPersistedSettings, calculateRamBasedLimits, } from './helpers/settingsStore';
+import { getNativeSystemMetrics, pushNativeLogRecord, fetchNativeCachedPage, } from './native/NativeInspector';
 // Network
 import { setupNetworkLogger, clearNetworkLogs, subscribeNetworkLogs, setNetworkModuleEnabled, } from './customHooks/networkLogger';
 // Console
@@ -22,6 +23,7 @@ import { subscribeAnalyticsEvents, clearAnalyticsEvents, autoSetupAnalyticsLogge
 import { getReduxState, subscribeReduxState, setReduxAutoRefresh, getLastActionForReducer, clearActionHistory, isReduxConnected, setReduxModuleEnabled, } from './customHooks/reduxLogger';
 import { setPerformanceModuleEnabled } from './customHooks/performanceTracker';
 import { setBundleModuleEnabled } from './customHooks/bundleAnalyzer';
+import { showNativeFloatingButton, hideNativeFloatingButton, setNativeFloatingButtonBadge, subscribeNativeFloatingButtonPress, subscribeNativeDeviceShake, isNativeModuleAvailable, } from './native/NativeInspector';
 import { LIB_VERSION } from './constants';
 // Stylesheet
 import { toggleGlobalTheme } from './styles';
@@ -174,6 +176,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         crash: false,
     });
     const [maxNetworkLogs, setMaxNetworkLogs] = useState(100);
+    const [maxAnalyticsEventsLimit, setMaxAnalyticsEventsLimit] = useState(250);
+    const [isAutoRamLimitEnabled, setIsAutoRamLimitEnabled] = useState(true);
+    const [deviceFreeRamMb, setDeviceFreeRamMb] = useState(1800);
     const [reduxAutoRefresh, setReduxAutoRefreshState] = useState(true);
     const [reduxExpandDepth, setReduxExpandDepth] = useState(1);
     // #6 — tab the inspector opens on. Shown with a DEFAULT badge in Settings.
@@ -189,6 +194,25 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         setCrashModuleEnabled(!!tabVisibility.crash);
         setBundleModuleEnabled(!!tabVisibility.bundle);
     }, [tabVisibility]);
+    // Query native hardware RAM and auto-tune limits if auto-RAM is active
+    useEffect(() => {
+        getNativeSystemMetrics()
+            .then(metrics => {
+            if (metrics) {
+                const freeRam = metrics.totalPhysicalRamMb - metrics.residentRamMb;
+                const freeMb = Math.max(200, Math.round(freeRam > 0 ? freeRam : 1500));
+                setDeviceFreeRamMb(freeMb);
+                if (isAutoRamLimitEnabled) {
+                    const profile = calculateRamBasedLimits(freeMb);
+                    setMaxNetworkLogs(profile.maxNetworkLogs);
+                    setMaxConsoleLogs(profile.maxConsoleLogs);
+                    setMaxAnalyticsEventsLimit(profile.maxAnalyticsEvents);
+                    setMaxCrashLogs(profile.maxCrashRecords);
+                }
+            }
+        })
+            .catch(() => { });
+    }, [isAutoRamLimitEnabled]);
     const resetToDefaults = async () => {
         await clearPersistedSettings();
         setIsDark(false);
@@ -205,9 +229,12 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
             crash: false,
         });
         setDefaultTab('apis');
-        setMaxCrashLogs(100);
-        setMaxNetworkLogs(100);
-        setMaxConsoleLogs(200);
+        setIsAutoRamLimitEnabled(true);
+        const profile = calculateRamBasedLimits(deviceFreeRamMb);
+        setMaxCrashLogs(profile.maxCrashRecords);
+        setMaxNetworkLogs(profile.maxNetworkLogs);
+        setMaxConsoleLogs(profile.maxConsoleLogs);
+        setMaxAnalyticsEventsLimit(profile.maxAnalyticsEvents);
         setShowConsoleLevels({
             info: true,
             warn: true,
@@ -241,10 +268,16 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
                 }));
             if (saved.defaultTab)
                 setDefaultTab(saved.defaultTab);
+            if (saved.isAutoRamLimitEnabled != null)
+                setIsAutoRamLimitEnabled(saved.isAutoRamLimitEnabled);
             if (saved.maxNetworkLogs != null)
                 setMaxNetworkLogs(saved.maxNetworkLogs);
             if (saved.maxConsoleLogs != null)
                 setMaxConsoleLogs(saved.maxConsoleLogs);
+            if (saved.maxAnalyticsEventsLimit != null)
+                setMaxAnalyticsEventsLimit(saved.maxAnalyticsEventsLimit);
+            if (saved.maxCrashLogs != null)
+                setMaxCrashLogs(saved.maxCrashLogs);
             if (saved.showConsoleLevels)
                 setShowConsoleLevels(saved.showConsoleLevels);
             if (saved.reduxAutoRefresh != null)
@@ -287,6 +320,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
             defaultTab,
             maxNetworkLogs,
             maxConsoleLogs,
+            maxAnalyticsEventsLimit,
+            maxCrashLogs,
+            isAutoRamLimitEnabled,
             showConsoleLevels,
             reduxAutoRefresh,
             reduxExpandDepth,
@@ -300,6 +336,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         defaultTab,
         maxNetworkLogs,
         maxConsoleLogs,
+        maxAnalyticsEventsLimit,
+        maxCrashLogs,
+        isAutoRamLimitEnabled,
         showConsoleLevels,
         reduxAutoRefresh,
         reduxExpandDepth,
@@ -374,13 +413,43 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
             return newVisibility;
         });
     };
+    const loadNativePage = useCallback(async (tabKey, query = '') => {
+        if (tabKey === 'apis' || tabKey === 'logs' || tabKey === 'analytics' || tabKey === 'crash') {
+            const pageData = await fetchNativeCachedPage(tabKey, 0, 100, query);
+            if (pageData && pageData.items && pageData.items.length > 0) {
+                if (tabKey === 'apis')
+                    setLogs(pageData.items);
+                else if (tabKey === 'logs')
+                    setConsoleLogs(pageData.items);
+                else if (tabKey === 'analytics')
+                    setAnalyticsEvents(pageData.items);
+                else if (tabKey === 'crash')
+                    setCrashRecords(pageData.items);
+            }
+        }
+    }, []);
     const switchActiveTab = useCallback((key) => {
         if (key === 'redux' && !isReduxConnected())
             return;
         if (key === 'analytics' && !isAnalyticsConnected())
             return;
-        setActiveTab(key);
-    }, []);
+        setSelected(null);
+        setSelectedEvent(null);
+        setSelectedLog(null);
+        setSelectedReduxSlice(null);
+        setSelectedReduxAction(null);
+        setSelectedCrash(null);
+        if (typeof React.startTransition === 'function') {
+            React.startTransition(() => {
+                setActiveTab(key);
+                loadNativePage(key);
+            });
+        }
+        else {
+            setActiveTab(key);
+            loadNativePage(key);
+        }
+    }, [loadNativePage]);
     const [selectedEvent, setSelectedEvent] = useState(null);
     const [analyticsSearch, setAnalyticsSearch] = useState('');
     const [analyticsFilters, setAnalyticsFilters] = useState({
@@ -628,6 +697,53 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         loop.start();
         return () => loop.stop();
     }, [unreadPulseAnim]);
+    const isNativeModule = useMemo(() => isNativeModuleAvailable(), []);
+    const useNativeFab = (Platform.OS === 'ios' || Platform.OS === 'android') && isNativeModule;
+    // 100% Native Main-Thread Floating Button Lifecycle
+    useEffect(() => {
+        if (!useNativeFab || !isEnabled || !enabled) {
+            if (useNativeFab) {
+                hideNativeFloatingButton();
+            }
+            return;
+        }
+        if (visible) {
+            hideNativeFloatingButton();
+        }
+        else {
+            showNativeFloatingButton();
+            setNativeFloatingButtonBadge(logs.length > 0 || analyticsEvents.length > 0);
+        }
+    }, [
+        useNativeFab,
+        isEnabled,
+        enabled,
+        visible,
+        logs.length,
+        analyticsEvents.length,
+    ]);
+    // Subscribe to native UI-thread floating button tap events
+    useEffect(() => {
+        if (!useNativeFab)
+            return;
+        const unsubscribe = subscribeNativeFloatingButtonPress(() => {
+            setVisible(true);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [useNativeFab]);
+    // Subscribe to physical hardware shake events (or Cmd+Ctrl+Z on iOS simulator)
+    useEffect(() => {
+        if (!useNativeFab)
+            return;
+        const unsubscribe = subscribeNativeDeviceShake(() => {
+            setVisible(prev => !prev);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [useNativeFab]);
     const isVisibleRefObj = useRef(visible);
     // #6 — every time the inspector is opened, land on chosen default tab & sync latest logs
     useEffect(() => {
@@ -694,6 +810,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
                 return;
             }
             const updated = getCrashRecords();
+            if (updated.length > 0) {
+                pushNativeLogRecord('crash', JSON.stringify(updated[0]));
+            }
             if (isVisibleRef.current) {
                 setCrashRecords(updated);
             }
@@ -702,12 +821,16 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         // during the very first commit, which fires before effects are mounted).
         const pendingCrashes = getCrashRecords();
         if (pendingCrashes.length > 0) {
+            pendingCrashes.forEach(c => pushNativeLogRecord('crash', JSON.stringify(c)));
             setCrashRecords(pendingCrashes);
         }
         let timeoutId;
         let isFirstNetworkCall = true;
         const unsubscribe = subscribeNetworkLogs((raw) => {
             latestNetworkLogsRef.current = raw;
+            if (raw.length > 0) {
+                pushNativeLogRecord('apis', JSON.stringify(raw[0]));
+            }
             if (isNetworkPausedRef.current)
                 return;
             if (!isVisibleRef.current)
@@ -749,6 +872,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         let isFirstAnalyticsCall = true;
         const unsubscribeAnalytics = subscribeAnalyticsEvents((raw) => {
             latestAnalyticsEventsRef.current = raw;
+            if (raw.length > 0) {
+                pushNativeLogRecord('analytics', JSON.stringify(raw[0]));
+            }
             if (isAnalyticsPausedRef.current)
                 return;
             if (!isVisibleRef.current)
@@ -788,6 +914,9 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         let isFirstConsoleCall = true;
         const unsubscribeConsole = subscribeConsoleLogs((raw) => {
             latestConsoleLogsRef.current = raw;
+            if (raw.length > 0) {
+                pushNativeLogRecord('logs', JSON.stringify(raw[0]));
+            }
             if (isConsolePausedRef.current)
                 return;
             if (!isVisibleRef.current)
@@ -858,6 +987,10 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
                         return true;
                     if (f === 'Failed')
                         return log.status === 0 || log.status == null;
+                    const codeNum = parseInt(f, 10);
+                    if (!isNaN(codeNum)) {
+                        return Number(log.status) === codeNum;
+                    }
                     return String(log.status)[0] === f[0];
                 });
                 if (!matched)
@@ -873,9 +1006,26 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
                 if (!matchedMethod)
                     return false;
             }
-            // Search Bar Check
-            if (search && !log.url?.toLowerCase().includes(search.toLowerCase()))
-                return false;
+            // Comprehensive Search Bar Check
+            if (search && search.trim().length > 0) {
+                const queryTokens = search.trim().toLowerCase().split(/\s+/).filter(Boolean);
+                const routePath = logRouteMapRef.current.get(log.id)?.path || '';
+                const reqStr = typeof log.request === 'string' ? log.request : JSON.stringify(log.request || '');
+                const resStr = typeof log.response === 'string' ? log.response : JSON.stringify(log.response || '');
+                const searchTarget = [
+                    log.method || '',
+                    log.url || '',
+                    String(log.status ?? ''),
+                    routePath,
+                    reqStr,
+                    resStr,
+                    JSON.stringify(log.requestHeaders || ''),
+                    JSON.stringify(log.responseHeaders || ''),
+                ].join(' ').toLowerCase();
+                const isMatch = queryTokens.every(token => searchTarget.includes(token));
+                if (!isMatch)
+                    return false;
+            }
             return true;
         });
         if (sortOrder === 'oldest') {
@@ -1030,12 +1180,20 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
     const filteredAnalyticsEvents = useMemo(() => {
         let events = analyticsEvents;
         // Search query filter
-        if (analyticsSearch) {
-            const s = analyticsSearch.toLowerCase();
-            events = events.filter(e => e.name.toLowerCase().includes(s) ||
-                JSON.stringify(e.params || {}).toLowerCase().includes(s) ||
-                (e.screenName ?? '').toLowerCase().includes(s) ||
-                (e.pageTitle ?? '').toLowerCase().includes(s));
+        if (analyticsSearch && analyticsSearch.trim().length > 0) {
+            const queryTokens = analyticsSearch.trim().toLowerCase().split(/\s+/).filter(Boolean);
+            events = events.filter(e => {
+                const searchTarget = [
+                    e.name || '',
+                    JSON.stringify(e.params || ''),
+                    JSON.stringify(e.userProperties || ''),
+                    e.screenName || '',
+                    e.pageTitle || '',
+                    e.userId || '',
+                    e.source || '',
+                ].join(' ').toLowerCase();
+                return queryTokens.every(token => searchTarget.includes(token));
+            });
         }
         // Category filter
         if (analyticsFilters.categories.size > 0 && !analyticsFilters.categories.has('all')) {
@@ -1073,16 +1231,15 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         }
         // Payload complexity filter
         if (analyticsFilters.payloadComplexity !== 'all') {
-            events = events.filter(e => {
-                const count = e.params ? Object.keys(e.params).length : 0;
-                if (analyticsFilters.payloadComplexity === 'none')
-                    return count === 0;
-                if (analyticsFilters.payloadComplexity === 'simple')
-                    return count >= 1 && count <= 5;
-                if (analyticsFilters.payloadComplexity === 'heavy')
-                    return count > 5;
-                return true;
-            });
+            if (analyticsFilters.payloadComplexity === 'none') {
+                events = events.filter(e => !e.params || Object.keys(e.params).length === 0);
+            }
+            else if (analyticsFilters.payloadComplexity === 'simple') {
+                events = events.filter(e => e.params && Object.keys(e.params).length <= 3);
+            }
+            else if (analyticsFilters.payloadComplexity === 'heavy') {
+                events = events.filter(e => e.params && Object.keys(e.params).length > 3);
+            }
         }
         // Conversion / Goal events filter
         if (analyticsFilters.onlyConversions) {
@@ -1115,10 +1272,8 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         }
         // Has Revenue filter
         if (analyticsFilters.hasRevenue) {
-            events = events.filter(e => {
-                const val = e.params?.value ?? e.params?.price;
-                return val !== undefined && val !== null && Number(val) > 0;
-            });
+            events = events.filter(e => (e.params?.value != null && !isNaN(Number(e.params.value))) ||
+                (e.params?.price != null && !isNaN(Number(e.params.price))));
         }
         // Has Items filter
         if (analyticsFilters.hasItems) {
@@ -1183,16 +1338,23 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
                 if (logFilters.has('user-log') && log.sourceMethod === 'log')
                     return true;
                 if (logFilters.has('analytics') &&
-                    log.message.toLowerCase().includes('[analytics error]'))
+                    log.message?.toLowerCase().includes('[analytics error]'))
                     return true;
                 return false;
             });
         }
-        // Search bar check
-        if (logSearch) {
-            const s = logSearch.toLowerCase();
-            result = result.filter(log => log.message.toLowerCase().includes(s) ||
-                (log.caller ?? '').toLowerCase().includes(s));
+        // Comprehensive Search bar check
+        if (logSearch && logSearch.trim().length > 0) {
+            const queryTokens = logSearch.trim().toLowerCase().split(/\s+/).filter(Boolean);
+            result = result.filter(log => {
+                const searchTarget = [
+                    log.message || '',
+                    log.caller || '',
+                    log.type || '',
+                    log.sourceMethod || '',
+                ].join(' ').toLowerCase();
+                return queryTokens.every(token => searchTarget.includes(token));
+            });
         }
         // #7 — apply sort order (newest/oldest first)
         result = [...result].sort((a, b) => logSortOrder === 'newest'
@@ -1229,10 +1391,17 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
     ]);
     const logCounts = useMemo(() => {
         let searchedLogs = visibleConsoleLogs;
-        if (logSearch) {
-            const s = logSearch.toLowerCase();
-            searchedLogs = visibleConsoleLogs.filter(log => log.message.toLowerCase().includes(s) ||
-                (log.caller ?? '').toLowerCase().includes(s));
+        if (logSearch && logSearch.trim().length > 0) {
+            const queryTokens = logSearch.trim().toLowerCase().split(/\s+/).filter(Boolean);
+            searchedLogs = visibleConsoleLogs.filter(log => {
+                const searchTarget = [
+                    log.message || '',
+                    log.caller || '',
+                    log.type || '',
+                    log.sourceMethod || '',
+                ].join(' ').toLowerCase();
+                return queryTokens.every(token => searchTarget.includes(token));
+            });
         }
         const total = visibleConsoleLogs.length;
         return {
@@ -1426,6 +1595,7 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         unreadPulseAnim,
         runClearAllWithAnimation,
         // ─── FAB / launcher ─────────────────────────────────────────────────
+        useNativeFab,
         fabPan,
         fabPanResponder,
         fabDraggedRef,
@@ -1543,6 +1713,11 @@ const NetworkInspector = ({ enabled = true, isEnabled = true, storage, navigatio
         setMaxNetworkLogs,
         maxConsoleLogs,
         setMaxConsoleLogs,
+        maxAnalyticsEventsLimit,
+        setMaxAnalyticsEventsLimit,
+        isAutoRamLimitEnabled,
+        setIsAutoRamLimitEnabled,
+        deviceFreeRamMb,
         reduxAutoRefresh,
         setReduxAutoRefreshState,
         reduxExpandDepth,
@@ -1576,4 +1751,5 @@ export { connectReduxStore, inspectorReduxMiddleware, getReduxState, subscribeRe
 export { getEventCategory, registerGAPlugin, } from './helpers/gaAnalyticsRegistry';
 export { usePerformanceTracker, useComponentProfiler, useNavigationProfiler, trackComponentRender, trackNavigationTransition, trackHeavyTask, measureAsync, getHermesMemoryStats, registerComponentProfile, subscribeRenderProfiles, getRenderProfiles, logPerformanceEvent, clearPerformanceEvents, subscribePerformanceEvents, getPerformanceEvents, getInitialRenderProfiles, getInitialPerformanceEvents, generateFixSnippet, } from './customHooks/performanceTracker';
 export { InspectLog, InspectTrackTime, InspectCatch, } from './decorators';
+export { getNativeDeviceMetrics, enableNativeCrashProtection, subscribeNativeCrashes, showNativeFloatingButton, hideNativeFloatingButton, setNativeFloatingButtonBadge, subscribeNativeFloatingButtonPress, subscribeNativeDeviceShake, startNativeFpsMonitoring, stopNativeFpsMonitoring, getNativeFpsMetrics, getNativeStorageItem, setNativeStorageItem, isNativeModuleAvailable, } from './native/NativeInspector';
 export { ActiveTab, Method, StatusFilter, SortOrder, LocalFilter, ModalAnimationType, SettingsPage, SettingsSubTab, LogFilter, ConsoleLogType, AnalyticsEventSource, GAEventCategory, StackFrameType, DiffResultType, BundleSubTab, PerformanceSubTab, CrashType, CrashExportFormat, CrashDetailSubTab, CrashFilterType, BreadcrumbType, } from './types';

package/dist/esm/native/NativeInspector.d.ts

@@ -0,0 +1,125 @@
+export interface NativeDeviceMetrics {
+    totalRAM?: number;
+    freeRAM?: number;
+    usedRAM?: number;
+    residentMemory?: number;
+    virtualMemory?: number;
+    isLowMemory?: boolean;
+    nativeHeapAllocated?: number;
+    nativeHeapSize?: number;
+    nativeHeapFree?: number;
+    freeStorage?: number;
+    totalStorage?: number;
+    batteryPercent?: number;
+    isCharging?: boolean;
+    deviceModel?: string;
+    deviceBrand?: string;
+    osVersion?: string;
+    apiLevel?: number;
+    cpuAbi?: string;
+}
+export interface NativeCrashEvent {
+    platform: 'android' | 'ios';
+    error: string;
+    name?: string;
+    stack?: string;
+    threadName?: string;
+    timestamp: number;
+}
+export declare const isNativeModuleAvailable: () => boolean;
+/**
+ * Retrieves low-level native hardware and system metrics (RAM, Heap, Disk, Battery, CPU).
+ */
+export declare const getNativeDeviceMetrics: () => Promise<NativeDeviceMetrics | null>;
+/**
+ * Enables native signal and uncaught exception protection in the iOS / Android runtime.
+ * Automatically ensures the native floating icon is shown and available before UI renders.
+ */
+export declare const enableNativeCrashProtection: (options?: {
+    showFloatingButton?: boolean;
+}) => Promise<boolean>;
+/**
+ * Subscribes to fatal native crash events caught by the iOS / Kotlin exception handlers.
+ */
+export declare const subscribeNativeCrashes: (callback: (event: NativeCrashEvent) => void) => (() => void);
+export interface FloatingButtonOptions {
+    size?: number;
+    x?: number;
+    y?: number;
+}
+/**
+ * Displays the 100% native main-thread floating overlay button.
+ * Dragging & touches run on the native UI thread, completely isolated from JS thread stalls.
+ */
+export declare const showNativeFloatingButton: (options?: FloatingButtonOptions) => Promise<boolean>;
+/**
+ * Hides the native floating overlay button.
+ */
+export declare const hideNativeFloatingButton: () => Promise<boolean>;
+/**
+ * Updates the badge/status dot on the native floating overlay button.
+ */
+export declare const setNativeFloatingButtonBadge: (hasBadge: boolean) => Promise<boolean>;
+/**
+ * Subscribes to tap events on the native floating button.
+ */
+export declare const subscribeNativeFloatingButtonPress: (callback: () => void) => (() => void);
+/**
+ * Starts hardware-accurate native UI thread FPS tracking (CADisplayLink / Choreographer).
+ */
+export declare const startNativeFpsMonitoring: () => Promise<boolean>;
+/**
+ * Stops native FPS tracking.
+ */
+export declare const stopNativeFpsMonitoring: () => Promise<boolean>;
+export interface NativeFpsMetrics {
+    fps: number;
+    targetFps: number;
+}
+/**
+ * Reads the latest live hardware FPS from CADisplayLink (iOS) or Choreographer (Android).
+ */
+export declare const getNativeFpsMetrics: () => Promise<NativeFpsMetrics>;
+/**
+ * Subscribes to physical hardware shake events (or Cmd+Ctrl+Z on iOS simulator).
+ */
+export declare const subscribeNativeDeviceShake: (callback: () => void) => (() => void);
+/**
+ * Reads a persisted value synchronously from native NSUserDefaults / SharedPreferences.
+ */
+export declare const getNativeStorageItem: (key: string) => Promise<string | null>;
+/**
+ * Persists a key-value pair to native NSUserDefaults / SharedPreferences with 0ms latency.
+ */
+export declare const setNativeStorageItem: (key: string, value: string | null) => Promise<boolean>;
+export type HapticStyle = 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error';
+/**
+ * Triggers hardware native haptic feedback (iOS UIFeedbackGenerator / Android VibrationEffect).
+ */
+export declare const triggerNativeHaptic: (style?: HapticStyle) => Promise<boolean>;
+export interface NativeSystemMetrics {
+    thermalState: 'nominal' | 'fair' | 'serious' | 'critical';
+    residentRamMb: number;
+    totalPhysicalRamMb: number;
+    fps: number;
+    activeCpuCores: number;
+}
+/**
+ * Retrieves live system thermal state and RAM telemetry directly from native layer.
+ */
+export declare const getNativeSystemMetrics: () => Promise<NativeSystemMetrics | null>;
+/**
+ * Pushes a log payload to native background worker queues for instant native page caching.
+ */
+export declare const pushNativeLogRecord: (pageKey: "apis" | "logs" | "analytics" | "crash", jsonPayload: string) => Promise<boolean>;
+export interface NativeCachedPageResult<T = any> {
+    pageKey: string;
+    total: number;
+    offset: number;
+    items: T[];
+}
+/**
+ * Fetches pre-indexed, pre-sliced page data directly from native background memory queues.
+ * Delivers instantaneous 0ms page loading without blocking JS render thread.
+ */
+export declare const fetchNativeCachedPage: <T = any>(pageKey: "apis" | "logs" | "analytics" | "crash", offset?: number, limit?: number, query?: string) => Promise<NativeCachedPageResult<T> | null>;