react-native-inapp-inspector 1.1.26 → 1.1.28

package/dist/esm/customHooks/bundleAnalyzer.js

@@ -1,4 +1,5 @@
 import { AppColors } from '../styles/AppColors';
+import { t } from '../i18n';
 // ─── Real Host App Bundle Analyzer ──────────────────────────────────────────
 //
 // Dynamically measures and analyzes the real JavaScript bundle and packages
@@ -248,25 +249,32 @@ const extractBundleModules = (bundleText) => {
     const modules = [];
     const seenIds = new Set();
     if (bundleText && bundleText.length > 0) {
-        // Primary high-speed Metro tail regex: matches }, <id>, [<deps>], "<path>"
-        const tailRegex = /\}\s*,\s*(\d+)\s*,\s*\[([\d,\s]*)\]\s*,\s*(?:"([^"\r\n]+)"|'([^'\r\n]+)')/g;
+        // 1. Primary Metro regex: matches }, <id>, [<deps>] or {<deps>}, "<path>"
+        const tailRegex = /\}\s*,\s*(\d+)\s*,\s*(?:\[[\s\S]*?\]|\{[\s\S]*?\})\s*,\s*(?:"([^"\r\n]+)"|'([^'\r\n]+)')/g;
         let match;
         while ((match = tailRegex.exec(bundleText)) !== null) {
             const id = parseInt(match[1], 10);
-            const depsStr = match[2];
-            const path = match[3] || match[4] || '';
-            const deps = depsStr
-                ? depsStr
-                    .split(',')
-                    .map(s => parseInt(s.trim(), 10))
-                    .filter(n => !isNaN(n))
-                : [];
+            const path = match[2] || match[3] || '';
             if (!seenIds.has(id) && path.length > 0) {
                 seenIds.add(id);
-                modules.push({ id, deps, path });
+                modules.push({ id, deps: [], path });
             }
         }
-        // Secondary fallback if tailRegex didn't find modules
+        // 2. SourceURL comment extraction (Metro dev server embeds //# sourceURL=... for every module)
+        const sourceUrlRegex = /\/\/[#@]\s*sourceURL=(?:https?:\/\/[^/\n\r]+\/|file:\/\/)?([^?\r\n#\s]+)/g;
+        let srcMatch;
+        let autoId = 900000;
+        while ((srcMatch = sourceUrlRegex.exec(bundleText)) !== null) {
+            const path = srcMatch[1];
+            if (path && path.length > 0 && !path.endsWith('.bundle')) {
+                const id = autoId++;
+                if (!seenIds.has(id)) {
+                    seenIds.add(id);
+                    modules.push({ id, deps: [], path });
+                }
+            }
+        }
+        // 3. Fallback scan for __d calls
         if (modules.length === 0) {
             const defineRe = /__d\s*\(/g;
             let m;
@@ -281,22 +289,13 @@ const extractBundleModules = (bundleText) => {
                 const idNum = parseInt(idMatch[1], 10);
                 if (seenIds.has(idNum))
                     continue;
-                const depsMatch = args[2].match(/\[([^\]]*)\]/);
-                const deps = [];
-                if (depsMatch) {
-                    const depRe = /\d+/g;
-                    let d;
-                    while ((d = depRe.exec(depsMatch[1])) !== null) {
-                        deps.push(parseInt(d[0], 10));
-                    }
-                }
                 const pathRaw = args[3].trim();
                 const pathMatch = pathRaw.match(/^["']([^"']+)["']$/);
                 const path = pathMatch ? pathMatch[1] : pathRaw;
                 if (path.length === 0 || path.length > 500)
                     continue;
                 seenIds.add(idNum);
-                modules.push({ id: idNum, deps, path });
+                modules.push({ id: idNum, deps: [], path });
             }
         }
     }
@@ -318,8 +317,28 @@ const getStaticStartupModuleIds = (bundleText) => {
     }
     return ids;
 };
-const findCommonDirectoryPrefix = (paths) => {
-    const absPaths = paths.filter(p => p.startsWith('/'));
+/**
+ * Dynamically computes the host app's project root directory without hardcoding any folder names.
+ * Uses node_modules boundary, root entry points (index/App/package.json), and common directory analysis.
+ */
+const detectProjectRoot = (allRawPaths) => {
+    const normPaths = allRawPaths.map(p => p.replace(/\\/g, '/'));
+    // 1. Extract from node_modules path (most definitive in Metro dev bundles)
+    for (const norm of normPaths) {
+        const nmIdx = norm.indexOf('/node_modules/');
+        if (nmIdx !== -1) {
+            return norm.slice(0, nmIdx + 1); // e.g. "/Users/user/Projects/my-app/"
+        }
+    }
+    // 2. Extract from root entrypoint files (e.g. /path/to/project/index.js or App.tsx)
+    for (const norm of normPaths) {
+        const match = norm.match(/^(.*\/)(?:index\.[jt]sx?|app\.[jt]sx?|package\.json)(?:[?#].*)?$/i);
+        if (match && match[1]) {
+            return match[1];
+        }
+    }
+    // 3. Fallback: lowest common directory ancestor among all absolute project paths
+    const absPaths = normPaths.filter(p => p.startsWith('/') && !p.includes('/node_modules/'));
     if (absPaths.length === 0)
         return '';
     if (absPaths.length === 1) {
@@ -327,20 +346,42 @@ const findCommonDirectoryPrefix = (paths) => {
         return lastSlash > 0 ? absPaths[0].slice(0, lastSlash + 1) : '';
     }
     const splitPaths = absPaths.map(p => p.split('/'));
-    let commonIndex = 0;
+    let commonLen = 0;
     const first = splitPaths[0];
-    while (commonIndex < first.length - 1) {
-        const segment = first[commonIndex];
-        if (splitPaths.every(p => p[commonIndex] === segment)) {
-            commonIndex++;
+    const minLen = Math.min(...splitPaths.map(sp => sp.length));
+    while (commonLen < minLen - 1) {
+        const seg = first[commonLen];
+        if (splitPaths.every(sp => sp[commonLen] === seg)) {
+            commonLen++;
         }
         else {
             break;
         }
     }
-    if (commonIndex === 0)
-        return '';
-    return first.slice(0, commonIndex).join('/') + '/';
+    return commonLen > 0 ? first.slice(0, commonLen).join('/') + '/' : '';
+};
+/**
+ * Normalizes absolute or relative module paths so they retain their full
+ * folder hierarchy from the host project root dynamically.
+ */
+const normalizeProjectRelativePath = (rawPath, projectRoot) => {
+    let clean = rawPath.replace(/\\/g, '/');
+    // Strip query parameters e.g. ?platform=ios or hashes
+    const qIdx = clean.search(/[?#]/);
+    if (qIdx !== -1) {
+        clean = clean.slice(0, qIdx);
+    }
+    // Strip file:// or http://.../ dev server URL prefixes
+    clean = clean.replace(/^(?:https?:\/\/[^/]+\/|file:\/\/)/, '');
+    // Strip dynamically detected project root prefix
+    if (projectRoot && clean.startsWith(projectRoot)) {
+        clean = clean.slice(projectRoot.length);
+    }
+    // Clean leading ../ sequences, ./, and leading /
+    clean = clean.replace(/^(\.\.\/)+/, '').replace(/^\.\//, '').replace(/^\/+/, '');
+    if (!clean)
+        clean = rawPath.split('/').pop() || rawPath;
+    return clean;
 };
 const isExternalPackage = (rawPath) => {
     // 1. Standard node_modules
@@ -451,19 +492,12 @@ export const parseBundleSource = (bundleText, totalBytes, scriptURL, isLive = tr
         }
         rawProjectItems.push({ mod, rawPath });
     }
-    // Calculate common prefix for absolute paths to cleanly extract host app project files
-    const commonPrefix = findCommonDirectoryPrefix(rawProjectItems.map(item => item.rawPath));
+    // Dynamically calculate project root prefix to cleanly extract all host app folders & files
+    const projectRoot = detectProjectRoot(modules.map(item => item.path));
     const discoveredFiles = [];
     let fileIdx = 0;
     for (const { mod, rawPath } of rawProjectItems) {
-        let cleanPath = rawPath;
-        if (commonPrefix && cleanPath.startsWith(commonPrefix)) {
-            cleanPath = cleanPath.slice(commonPrefix.length);
-        }
-        // Clean leading ../ sequences, ./, and leading /
-        cleanPath = cleanPath.replace(/^(\.\.\/)+/, '').replace(/^\.\//, '').replace(/^\/+/, '');
-        if (!cleanPath)
-            cleanPath = rawPath.split('/').pop() || rawPath;
+        const cleanPath = normalizeProjectRelativePath(rawPath, projectRoot);
         const isLocalFile = cleanPath.endsWith('.tsx') ||
             cleanPath.endsWith('.ts') ||
             cleanPath.endsWith('.jsx') ||
@@ -537,43 +571,6 @@ export const parseBundleSource = (bundleText, totalBytes, scriptURL, isLive = tr
             isConsumed,
         });
     }
-    // If no modules could be parsed (e.g. Hermes bytecode / obfuscated bundle), synthesize from loaded modules
-    if (discoveredFiles.length === 0) {
-        discoveredFiles.push({
-            id: 'hf-1',
-            name: 'index.js (App Entry)',
-            path: 'index.js',
-            ext: 'JS',
-            category: 'javascript',
-            sizeKb: Math.round(totalDevKb * 0.08),
-            meta: 'React Native Root Entrypoint',
-            color: AppColors.indigo500,
-            status: 'optimal',
-            isConsumed: true,
-        }, {
-            id: 'hf-2',
-            name: 'App.tsx',
-            path: 'src/App.tsx',
-            ext: 'TSX',
-            category: 'typescript',
-            sizeKb: Math.round(totalDevKb * 0.12),
-            meta: 'Root Navigation & Provider Container',
-            color: AppColors.sky500,
-            status: 'optimal',
-            isConsumed: true,
-        }, {
-            id: 'hf-3',
-            name: 'HomeScreen.tsx',
-            path: 'src/screens/HomeScreen.tsx',
-            ext: 'TSX',
-            category: 'typescript',
-            sizeKb: Math.round(totalDevKb * 0.06),
-            meta: 'Main Dashboard Screen View',
-            color: AppColors.sky500,
-            status: 'optimal',
-            isConsumed: true,
-        });
-    }
     // Dynamic color palette generator based on package name hash
     const getPackageColor = (name) => {
         const colors = [
@@ -726,105 +723,105 @@ export const parseBundleSource = (bundleText, totalBytes, scriptURL, isLive = tr
     const iosComponents = [
         {
             id: 'ios-c1',
-            name: 'Frameworks & Dynamic Pods',
+            name: t('bundle.iosComp1Name'),
             category: 'frameworks',
             sizeMb: nativeFrameworksMb,
             pct: Number(((nativeFrameworksMb / iosInstallMb) * 100).toFixed(1)),
             color: AppColors.indigo500,
-            description: `React, Hermes, and ${packagesList.length} native pod frameworks.`,
-            advice: 'Ensure Dead Code Stripping (STRIP_INSTALLED_PRODUCT = YES) in Release mode.',
+            description: t('bundle.iosComp1Desc', { count: packagesList.length }),
+            advice: t('bundle.iosComp1Advice'),
         },
         {
             id: 'ios-c2',
-            name: 'Mach-O Executable (ARM64)',
+            name: t('bundle.iosComp2Name'),
             category: 'native',
             sizeMb: nativeMachoMb,
             pct: Number(((nativeMachoMb / iosInstallMb) * 100).toFixed(1)),
             color: AppColors.sky500,
-            description: 'Host App compiled Swift/Objective-C and C++ native bridges.',
-            advice: 'Enable Monolithic LTO (Link-Time Optimization) in Xcode Scheme.',
+            description: t('bundle.iosComp2Desc'),
+            advice: t('bundle.iosComp2Advice'),
         },
         {
             id: 'ios-c3',
-            name: 'Asset Catalog (Assets.car)',
+            name: t('bundle.iosComp3Name'),
             category: 'assets',
             sizeMb: assetsCatalogMb,
             pct: Number(((assetsCatalogMb / iosInstallMb) * 100).toFixed(1)),
             color: AppColors.pink500,
-            description: 'AppIcons, splash screens, vector glyphs, and bundled fonts.',
-            advice: 'Compile images into Xcode Asset Catalog for automatic App Thinning.',
+            description: t('bundle.iosComp3Desc'),
+            advice: t('bundle.iosComp3Advice'),
         },
         {
             id: 'ios-c4',
-            name: 'Hermes Bytecode (main.jsbundle)',
+            name: t('bundle.iosComp4Name'),
             category: 'js',
             sizeMb: releaseJsMb,
             pct: Number(((releaseJsMb / iosInstallMb) * 100).toFixed(1)),
             color: AppColors.emerald500,
-            description: `Host app JavaScript compiled AOT into Hermes bytecode (${discoveredFiles.length} files).`,
-            advice: 'AOT bytecode loads with 0ms compile latency on device launch.',
+            description: t('bundle.iosComp4Desc', { count: discoveredFiles.length }),
+            advice: t('bundle.iosComp4Advice'),
         },
         {
             id: 'ios-c5',
-            name: 'Metadata & Code Signatures',
+            name: t('bundle.iosComp5Name'),
             category: 'meta',
             sizeMb: metadataMb,
             pct: Number(((metadataMb / iosInstallMb) * 100).toFixed(1)),
             color: AppColors.amber500,
-            description: '_CodeSignature, Info.plist, and entitlements block.',
-            advice: 'Standard Apple Code Signing & provisioning signature.',
+            description: t('bundle.iosComp5Desc'),
+            advice: t('bundle.iosComp5Advice'),
         },
     ];
     const androidComponents = [
         {
             id: 'and-c1',
-            name: 'Native C++ Libraries (.so)',
+            name: t('bundle.andComp1Name'),
             category: 'native',
             sizeMb: androidCppMb,
             pct: Number(((androidCppMb / androidInstallMb) * 100).toFixed(1)),
             color: AppColors.sky500,
-            description: `libhermes.so, libfbjni.so, and ${packagesList.length} C++ native adapters.`,
-            advice: 'Deploy with Android App Bundle (.aab) to deliver per-ABI split APKs.',
+            description: t('bundle.andComp1Desc', { count: packagesList.length }),
+            advice: t('bundle.andComp1Advice'),
         },
         {
             id: 'and-c2',
-            name: 'Compiled DEX (classes.dex)',
+            name: t('bundle.andComp2Name'),
             category: 'frameworks',
             sizeMb: androidDexMb,
             pct: Number(((androidDexMb / androidInstallMb) * 100).toFixed(1)),
             color: AppColors.indigo500,
-            description: 'Compiled Java & Kotlin runtime, AndroidX, and React Native bridges.',
-            advice: 'Enable R8 / ProGuard shrinking (minifyEnabled true) in build.gradle.',
+            description: t('bundle.andComp2Desc'),
+            advice: t('bundle.andComp2Advice'),
         },
         {
             id: 'and-c3',
-            name: 'Android Resources (res/)',
+            name: t('bundle.andComp3Name'),
             category: 'assets',
             sizeMb: androidResMb,
             pct: Number(((androidResMb / androidInstallMb) * 100).toFixed(1)),
             color: AppColors.pink500,
-            description: 'Drawables, vector XMLs, mipmap densities, resources.arsc, fonts.',
-            advice: 'Use WebP and VectorDrawables to avoid multi-density asset duplication.',
+            description: t('bundle.andComp3Desc'),
+            advice: t('bundle.andComp3Advice'),
         },
         {
             id: 'and-c4',
-            name: 'Hermes Bytecode (Android)',
+            name: t('bundle.andComp4Name'),
             category: 'js',
             sizeMb: releaseJsMb,
             pct: Number(((releaseJsMb / androidInstallMb) * 100).toFixed(1)),
             color: AppColors.emerald500,
-            description: `Host app JavaScript compiled into Hermes bytecode (${discoveredFiles.length} files).`,
-            advice: 'Pre-compiled bytecode during assembleRelease gradle task.',
+            description: t('bundle.andComp4Desc', { count: discoveredFiles.length }),
+            advice: t('bundle.andComp4Advice'),
         },
         {
             id: 'and-c5',
-            name: 'Manifest & Signatures (META-INF)',
+            name: t('bundle.andComp5Name'),
             category: 'meta',
             sizeMb: 2.6,
             pct: Number(((2.6 / androidInstallMb) * 100).toFixed(1)),
             color: AppColors.amber500,
-            description: 'AndroidManifest.xml, signing certs, v2/v3/v4 APK Signature Scheme blocks.',
-            advice: 'Official Google Play signing & signature block.',
+            description: t('bundle.andComp5Desc'),
+            advice: t('bundle.andComp5Advice'),
         },
     ];
     // Universal Standalone APK metrics (Multi-ABI FAT APK: arm64 + v7a + x86_64)
@@ -834,53 +831,53 @@ export const parseBundleSource = (bundleText, totalBytes, scriptURL, isLive = tr
     const androidApkComponents = [
         {
             id: 'apk-c1',
-            name: 'Multi-ABI C++ Libraries (.so)',
+            name: t('bundle.apkComp1Name'),
             category: 'native',
             sizeMb: androidMultiAbiCppMb,
             pct: Number(((androidMultiAbiCppMb / androidApkInstallMb) * 100).toFixed(1)),
             color: AppColors.sky500,
-            description: 'Universal multi-architecture shared libraries (.so) bundled for direct sideloading.',
-            advice: 'Use Android App Bundle (.aab) for Google Play to reduce install size by 60%.',
+            description: t('bundle.apkComp1Desc'),
+            advice: t('bundle.apkComp1Advice'),
         },
         {
             id: 'apk-c2',
-            name: 'Compiled DEX Bytecode (classes.dex)',
+            name: t('bundle.apkComp2Name'),
             category: 'frameworks',
             sizeMb: androidDexMb,
             pct: Number(((androidDexMb / androidApkInstallMb) * 100).toFixed(1)),
             color: AppColors.indigo500,
-            description: 'Compiled Java & Kotlin runtime, AndroidX libraries, and native bridge modules.',
-            advice: 'Enable R8 / ProGuard shrinking (minifyEnabled true) and shrinkResources true.',
+            description: t('bundle.apkComp2Desc'),
+            advice: t('bundle.apkComp2Advice'),
         },
         {
             id: 'apk-c3',
-            name: 'Android Resources & Assets (res/)',
+            name: t('bundle.apkComp3Name'),
             category: 'assets',
             sizeMb: androidResMb,
             pct: Number(((androidResMb / androidApkInstallMb) * 100).toFixed(1)),
             color: AppColors.pink500,
-            description: 'Drawables, vector XMLs, mipmap densities, resources.arsc, fonts.',
-            advice: 'Use WebP and VectorDrawables to avoid multi-density asset duplication.',
+            description: t('bundle.apkComp3Desc'),
+            advice: t('bundle.apkComp3Advice'),
         },
         {
             id: 'apk-c4',
-            name: 'Hermes Bytecode Bundle (Android)',
+            name: t('bundle.apkComp4Name'),
             category: 'js',
             sizeMb: releaseJsMb,
             pct: Number(((releaseJsMb / androidApkInstallMb) * 100).toFixed(1)),
             color: AppColors.emerald500,
-            description: `Host app JavaScript compiled into Hermes bytecode (${discoveredFiles.length} files).`,
-            advice: 'Pre-compiled bytecode during assembleRelease gradle task.',
+            description: t('bundle.apkComp4Desc', { count: discoveredFiles.length }),
+            advice: t('bundle.apkComp4Advice'),
         },
         {
             id: 'apk-c5',
-            name: 'Manifest & Signatures (META-INF)',
+            name: t('bundle.apkComp5Name'),
             category: 'meta',
             sizeMb: 3.2,
             pct: Number(((3.2 / androidApkInstallMb) * 100).toFixed(1)),
             color: AppColors.amber500,
-            description: 'AndroidManifest.xml, signing certs, JAR & v2/v3/v4 APK Signature Scheme.',
-            advice: 'Enterprise sideload & direct install signature block.',
+            description: t('bundle.apkComp5Desc'),
+            advice: t('bundle.apkComp5Advice'),
         },
     ];
     return {

package/dist/esm/customHooks/networkLogger.d.ts

@@ -8,6 +8,7 @@ type NetworkLog = {
     duration?: number;
     startTime: number;
     caller?: string;
+    client?: string;
     requestHeaders?: Record<string, string>;
     responseHeaders?: Record<string, string>;
 };

package/dist/esm/customHooks/networkLogger.js

@@ -145,15 +145,26 @@ export const setupNetworkLogger = () => {
                 return originalFetch(url, options);
             let caller = "Unknown";
             let requestHeaders;
+            let client = 'fetch';
             try {
                 requestHeaders = normaliseHeaders(options?.headers);
                 caller = getCallerFromStack(); // ✅ Capture call line
+                if (requestHeaders?.['apollographql-client-name'] || finalUrl?.toLowerCase().includes('/graphql')) {
+                    client = 'apollo';
+                }
+                else if (requestHeaders?.['x-requested-with']?.toLowerCase().includes('xmlhttprequest')) {
+                    client = 'xhr';
+                }
+                else if (caller?.toLowerCase().includes('axios')) {
+                    client = 'axios';
+                }
                 addOrUpdateLog({
                     id,
                     url: finalUrl,
                     method,
                     startTime: start,
                     caller,
+                    client,
                     request: method === "GET" ? undefined : parseRequestData(options?.body),
                     requestHeaders,
                 });
@@ -193,6 +204,7 @@ export const setupNetworkLogger = () => {
                         duration,
                         startTime: start,
                         caller,
+                        client,
                         responseHeaders,
                     });
                 }
@@ -209,6 +221,7 @@ export const setupNetworkLogger = () => {
                         startTime: start,
                         response: error,
                         caller,
+                        client,
                         duration: Date.now() - start,
                     });
                 }
@@ -264,6 +277,7 @@ export const addAxiosInterceptors = (axiosInstance) => {
             method,
             startTime: start,
             caller,
+            client: 'axios',
             request: method === "GET" ? undefined : parseRequestData(config.data),
             requestHeaders: normaliseHeaders(config.headers),
         });
@@ -289,6 +303,7 @@ export const addAxiosInterceptors = (axiosInstance) => {
             startTime: start || Date.now(),
             duration: start != null ? Date.now() - start : undefined,
             caller,
+            client: 'axios',
             responseHeaders: normaliseHeaders(response.headers),
         });
         return response;
@@ -311,6 +326,7 @@ export const addAxiosInterceptors = (axiosInstance) => {
                 startTime: start || Date.now(),
                 duration: start != null ? Date.now() - start : undefined,
                 caller,
+                client: 'axios',
                 responseHeaders: normaliseHeaders(error.response?.headers),
             });
         }

package/dist/esm/customHooks/performanceTracker.d.ts

@@ -5,6 +5,11 @@ export interface PerformanceEvent {
     category: 'render' | 'navigation' | 'memory' | 'io' | 'bridge';
     fps: number;
     durationMs: number;
+    droppedFrames?: number;
+    frameTimeMs?: number;
+    frameBudgetPct?: number;
+    bottleneckThread?: 'JS Thread' | 'UI Thread' | 'Bridge' | 'Balanced';
+    screenName?: string;
     label: string;
     detail: string;
     source?: string;
@@ -54,7 +59,76 @@ export interface ComponentRenderProfile {
     fixKeys: PerformanceFixKey[];
     severity: 'optimal' | 'warning' | 'critical';
 }
+/**
+ * Dynamically generates tailored Before/After performance optimization code snippets
+ * based on the target component's real identifier, props, and detected anti-pattern.
+ */
+export declare const generateFixSnippet: (fixKey: string, componentName?: string, context?: {
+    propName?: string;
+    actionName?: string;
+    itemHeight?: number;
+}) => PerformanceFixKey;
+/**
+ * Dynamically resolves caller file path or runtime source from the active JavaScript stack trace.
+ * Does not assume fixed directory hierarchies (such as src/ or components/) and extracts
+ * whatever relative path or symbol the host project structure uses.
+ */
+export declare function getCallerSourceFile(fallbackName?: string): string;
+export declare const getInitialRenderProfiles: () => ComponentRenderProfile[];
+export declare const getInitialPerformanceEvents: () => PerformanceEvent[];
 export declare const INITIAL_EVENTS: PerformanceEvent[];
+export declare const subscribeRenderProfiles: (listener: (profiles: ComponentRenderProfile[]) => void) => () => void;
+export declare const getRenderProfiles: () => ComponentRenderProfile[];
+export declare const registerComponentProfile: (profile: ComponentRenderProfile) => void;
+export declare const trackComponentRender: (params: {
+    name: string;
+    type?: ComponentRenderProfile["type"];
+    sourceFile?: string;
+    renderTimeMs?: number;
+    isWasteful?: boolean;
+    reason?: string;
+    fixKeys?: PerformanceFixKey[];
+}) => void;
+/**
+ * Dynamically queries Hermes or JavaScript runtime memory statistics.
+ */
+export declare const getHermesMemoryStats: () => LiveMemoryStats;
+/**
+ * Dynamically records and evaluates screen navigation transition performance.
+ */
+export declare const trackNavigationTransition: (screenName: string, durationMs: number, options?: {
+    ttiMs?: number;
+    droppedFrames?: number;
+    source?: string;
+}) => PerformanceEvent;
+/**
+ * React Hook that automatically profiles screen mounts and navigation transitions.
+ */
+export declare const useNavigationProfiler: (screenName: string, options?: {
+    onTransitionEnd?: (durationMs: number) => void;
+}) => void;
+/**
+ * Measures synchronous execution duration and alerts on frame budget spikes (>16ms).
+ */
+export declare const trackHeavyTask: <T>(taskName: string, syncFn: () => T, options?: {
+    thresholdMs?: number;
+    source?: string;
+}) => T;
+/**
+ * Measures async operation / Promise latency and records slow network or disk tasks.
+ */
+export declare const measureAsync: <T>(taskName: string, asyncFn: () => Promise<T>, options?: {
+    thresholdMs?: number;
+    source?: string;
+}) => Promise<T>;
+/**
+ * Custom React Hook to profile any component or screen renders dynamically in runtime.
+ */
+export declare const useComponentProfiler: (componentName: string, options?: {
+    type?: ComponentRenderProfile["type"];
+    sourceFile?: string;
+    propsToCompare?: Record<string, any>;
+}) => void;
 export declare const usePerformanceTracker: () => {
     isRecording: boolean;
     setIsRecording: import("react").Dispatch<import("react").SetStateAction<boolean>>;