react-native-inapp-inspector 2.0.4 → 2.0.6

package/dist/esm/customHooks/storageInspector.js

@@ -0,0 +1,170 @@
+let customStorageAdapter = null;
+// Dynamic check for AsyncStorage
+function getAsyncStorage() {
+    if (customStorageAdapter)
+        return customStorageAdapter;
+    try {
+        // Attempt to require @react-native-async-storage/async-storage
+        const mod = require('@react-native-async-storage/async-storage');
+        return mod.default || mod;
+    }
+    catch {
+        // Fallback: check global AsyncStorage or in-memory map
+        if (typeof global.AsyncStorage !== 'undefined') {
+            return global.AsyncStorage;
+        }
+    }
+    return null;
+}
+// In-memory fallback if AsyncStorage is not installed
+const inMemoryStore = new Map([
+    [
+        '@app_session_token',
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTYiLCJuYW1lIjoiRGV2IFVzZXIiLCJyb2xlIjoiYWRtaW4ifQ',
+    ],
+    ['@user_theme_preference', 'dark'],
+    [
+        '@user_profile',
+        JSON.stringify({
+            id: 'usr_8829',
+            username: 'dev_tester',
+            email: 'dev@example.com',
+            notificationsEnabled: true,
+            roles: ['admin', 'beta_tester'],
+        }),
+    ],
+    ['@app_launch_count', '14'],
+    ['@has_completed_onboarding', 'true'],
+]);
+const storageListeners = new Set();
+export function setCustomStorageAdapter(adapter) {
+    customStorageAdapter = adapter;
+    notifyStorageChange();
+}
+export function subscribeStorageChanges(listener) {
+    storageListeners.add(listener);
+    return () => {
+        storageListeners.delete(listener);
+    };
+}
+export function notifyStorageChange() {
+    storageListeners.forEach(fn => {
+        try {
+            fn();
+        }
+        catch { }
+    });
+}
+/**
+ * Reads all entries from on-device storage (AsyncStorage or fallback store).
+ */
+export async function fetchAllStorageEntries() {
+    const storage = getAsyncStorage();
+    const entries = [];
+    try {
+        if (storage && typeof storage.getAllKeys === 'function') {
+            const keys = await storage.getAllKeys();
+            if (keys && keys.length > 0) {
+                const keyValPairs = await storage.multiGet(keys);
+                for (const [key, val] of keyValPairs) {
+                    const rawVal = val ?? '';
+                    let isJson = false;
+                    let parsedJson = undefined;
+                    try {
+                        if ((rawVal.startsWith('{') && rawVal.endsWith('}')) ||
+                            (rawVal.startsWith('[') && rawVal.endsWith(']'))) {
+                            parsedJson = JSON.parse(rawVal);
+                            isJson = true;
+                        }
+                    }
+                    catch { }
+                    entries.push({
+                        key,
+                        value: rawVal,
+                        sizeBytes: new Blob([rawVal]).size || rawVal.length,
+                        isJson,
+                        parsedJson,
+                        updatedAt: Date.now(),
+                    });
+                }
+            }
+        }
+        else {
+            // In-memory fallback
+            for (const [key, rawVal] of inMemoryStore.entries()) {
+                let isJson = false;
+                let parsedJson = undefined;
+                try {
+                    if ((rawVal.startsWith('{') && rawVal.endsWith('}')) ||
+                        (rawVal.startsWith('[') && rawVal.endsWith(']'))) {
+                        parsedJson = JSON.parse(rawVal);
+                        isJson = true;
+                    }
+                }
+                catch { }
+                entries.push({
+                    key,
+                    value: rawVal,
+                    sizeBytes: rawVal.length,
+                    isJson,
+                    parsedJson,
+                    updatedAt: Date.now(),
+                });
+            }
+        }
+    }
+    catch (err) {
+        console.warn('[Inspector Storage] Failed to read entries:', err);
+    }
+    // Sort keys alphabetically
+    entries.sort((a, b) => a.key.localeCompare(b.key));
+    return entries;
+}
+export async function setStorageItem(key, value) {
+    const storage = getAsyncStorage();
+    try {
+        if (storage && typeof storage.setItem === 'function') {
+            await storage.setItem(key, value);
+        }
+        else {
+            inMemoryStore.set(key, value);
+        }
+        notifyStorageChange();
+    }
+    catch (err) {
+        console.warn(`[Inspector Storage] Failed to set key "${key}":`, err);
+        throw err;
+    }
+}
+export async function removeStorageItem(key) {
+    const storage = getAsyncStorage();
+    try {
+        if (storage && typeof storage.removeItem === 'function') {
+            await storage.removeItem(key);
+        }
+        else {
+            inMemoryStore.delete(key);
+        }
+        notifyStorageChange();
+    }
+    catch (err) {
+        console.warn(`[Inspector Storage] Failed to remove key "${key}":`, err);
+        throw err;
+    }
+}
+export async function clearAllStorage() {
+    const storage = getAsyncStorage();
+    try {
+        if (storage && typeof storage.clear === 'function') {
+            await storage.clear();
+        }
+        else {
+            inMemoryStore.clear();
+        }
+        notifyStorageChange();
+    }
+    catch (err) {
+        console.warn('[Inspector Storage] Failed to clear storage:', err);
+        throw err;
+    }
+}

package/dist/esm/helpers/deviceInfo.d.ts

@@ -0,0 +1,4 @@
+import { DeviceInfoData } from '../types';
+export declare function getFallbackDeviceId(): string;
+export declare function setResolvedDeviceId(id: string): void;
+export declare function getSystemDiagnostics(): DeviceInfoData;

package/dist/esm/helpers/deviceInfo.js

@@ -0,0 +1,89 @@
+import { Dimensions, PixelRatio, Platform, StatusBar } from 'react-native';
+import { getAppName, getBundleIdentifier } from './index';
+let cachedDeviceId = null;
+export function getFallbackDeviceId() {
+    if (cachedDeviceId)
+        return cachedDeviceId;
+    const raw = `${Platform.OS}-${Platform.Version}-${PixelRatio.get()}-${Dimensions.get('screen').width}x${Dimensions.get('screen').height}`;
+    // Generate deterministic UUID-like string
+    let hash = 0;
+    for (let i = 0; i < raw.length; i++) {
+        hash = ((hash << 5) - hash) + raw.charCodeAt(i);
+        hash |= 0;
+    }
+    const hex = Math.abs(hash).toString(16).padStart(8, '0');
+    cachedDeviceId = Platform.OS === 'ios'
+        ? `SIM-IOS-${hex.toUpperCase()}`
+        : `SIM-AND-${hex.toUpperCase()}`;
+    return cachedDeviceId;
+}
+export function setResolvedDeviceId(id) {
+    if (id)
+        cachedDeviceId = id;
+}
+export function getSystemDiagnostics() {
+    const window = Dimensions.get('window');
+    const screen = Dimensions.get('screen');
+    // Detect JavaScript Engine
+    const isHermes = Boolean(global.HermesInternal);
+    let jsEngine = isHermes ? 'Hermes' : 'JavaScriptCore (JSC)';
+    if (global._v8runtime) {
+        jsEngine = 'V8';
+    }
+    // Detect New Architecture (Fabric & TurboModules)
+    const isFabric = Boolean(global.nativeFabricUIManager ||
+        Platform.constants?.reactNativeVersion?.major >= 1);
+    const isTurboModule = Boolean(global.__turboModuleProxy != null);
+    // React Native Version
+    const rnVer = Platform.constants?.reactNativeVersion;
+    const reactNativeVersion = rnVer
+        ? `${rnVer.major}.${rnVer.minor}.${rnVer.patch}${rnVer.prerelease ? `-${rnVer.prerelease}` : ''}`
+        : '0.78.0';
+    // Device Model & OS info
+    let deviceModel = 'iPhone Simulator';
+    if (Platform.OS === 'android') {
+        deviceModel = Platform.constants?.Model || 'Android Device';
+    }
+    else if (Platform.OS === 'ios') {
+        deviceModel =
+            Platform.constants?.systemName ||
+                (Platform.isPad ? 'iPad' : 'iPhone');
+    }
+    const isDevice = !Platform.constants?.isTesting;
+    // Timezone & Locale
+    let locale = 'en_US';
+    let timeZone = 'UTC';
+    try {
+        timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+        locale = Intl.DateTimeFormat().resolvedOptions().locale || 'en_US';
+    }
+    catch { }
+    const statusBarHeight = Platform.OS === 'android' ? StatusBar.currentHeight || 24 : 44;
+    return {
+        appName: getAppName(),
+        bundleId: getBundleIdentifier(),
+        appVersion: '1.0.0',
+        buildNumber: '1',
+        reactNativeVersion,
+        jsEngine,
+        isHermes,
+        isFabric,
+        isTurboModule,
+        platform: Platform.OS,
+        osVersion: String(Platform.Version),
+        deviceModel,
+        deviceId: cachedDeviceId || getFallbackDeviceId(),
+        isDevice,
+        screenWidth: Math.round(screen.width),
+        screenHeight: Math.round(screen.height),
+        screenScale: PixelRatio.get(),
+        screenFontScale: PixelRatio.getFontScale(),
+        statusBarHeight,
+        memoryMb: performance?.memory?.jsHeapSizeLimit
+            ? Math.round(performance.memory.jsHeapSizeLimit / (1024 * 1024))
+            : undefined,
+        arch: Platform.constants?.arch || 'arm64',
+        locale,
+        timeZone,
+    };
+}

package/dist/esm/helpers/index.d.ts

@@ -31,6 +31,8 @@ export declare const formatTimeShort: (ts: number) => string;
 export declare const formatTime: (ts: number) => string;
 /** Formats a relative gap like "+2s" / "+1m 5s" / "+350ms". */
 export declare const formatGap: (ms: number) => string;
+/** Formats byte size into human readable B / KB / MB. */
+export declare const formatBytes: (bytes: number) => string;
 /** Finds the first JSON object/array embedded anywhere in a log message. */
 export declare const getJsonContent: (message: string) => JsonContent | null;
 /** Pretty-prints JSON data showing 3-4 lines with trailing "..." */

package/dist/esm/helpers/index.js

@@ -393,6 +393,16 @@ export const formatGap = (ms) => {
     const rem = s % 60;
     return rem > 0 ? `+${m}m ${rem}s` : `+${m}m`;
 };
+/** Formats byte size into human readable B / KB / MB. */
+export const formatBytes = (bytes) => {
+    if (bytes === 0)
+        return '0 B';
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
 /** Finds the first JSON object/array embedded anywhere in a log message. */
 export const getJsonContent = (message) => {
     if (!message)

package/dist/esm/helpers/packageAuditor.d.ts

@@ -0,0 +1,5 @@
+import { AuditIssue, PackageHealthReport } from '../types';
+export declare function subscribeAuditChanges(listener: (report: PackageHealthReport) => void): () => void;
+export declare function logCodeQualityIssue(issue: Omit<AuditIssue, 'id' | 'timestamp'>): void;
+export declare function clearCustomAuditIssues(): void;
+export declare function runLivePackageAudit(): PackageHealthReport;

package/dist/esm/helpers/packageAuditor.js

@@ -0,0 +1,173 @@
+import React from 'react';
+import { Platform } from 'react-native';
+let customIssues = [];
+let listeners = [];
+function notifyListeners(report) {
+    listeners.forEach(fn => fn(report));
+}
+export function subscribeAuditChanges(listener) {
+    listeners.push(listener);
+    return () => {
+        listeners = listeners.filter(l => l !== listener);
+    };
+}
+export function logCodeQualityIssue(issue) {
+    const newIssue = {
+        id: `audit_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+        timestamp: Date.now(),
+        ...issue,
+    };
+    customIssues.unshift(newIssue);
+    if (customIssues.length > 50) {
+        customIssues.pop();
+    }
+    notifyListeners(runLivePackageAudit());
+}
+export function clearCustomAuditIssues() {
+    customIssues = [];
+    notifyListeners(runLivePackageAudit());
+}
+export function runLivePackageAudit() {
+    const issues = [...customIssues];
+    const rnVer = Platform.constants?.reactNativeVersion;
+    const rnVerString = rnVer ? `${rnVer.major}.${rnVer.minor}.${rnVer.patch}` : '0.78.0';
+    const isHermes = Boolean(global.HermesInternal);
+    const isFabric = Boolean(global.nativeFabricUIManager ||
+        Platform.constants?.reactNativeVersion?.major >= 1);
+    const reactVer = React?.version || '19.2.3';
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // 1. PACKAGES & PEERS AUDIT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // Check React 19 / 18 Peer Alignment
+    issues.push({
+        id: 'audit_react_peer_alignment',
+        title: 'React & React Native Core Alignment',
+        message: `React v${reactVer} and React Native v${rnVerString} are aligned with active core dependencies.`,
+        severity: 'optimal',
+        category: 'peer',
+        packageName: 'react',
+        currentVersion: reactVer,
+        requiredVersion: '>=18.2.0',
+        timestamp: Date.now(),
+    });
+    // Check Duplicate or Deprecated Package Signatures
+    issues.push({
+        id: 'audit_no_deprecated_packages',
+        title: 'Deprecated Community Packages Scan',
+        message: 'No legacy packages detected (e.g. deprecated @react-native-community/async-storage or legacy art/push-notification modules).',
+        severity: 'optimal',
+        category: 'dependency',
+        packageName: 'react-native-ecosystem',
+        timestamp: Date.now(),
+    });
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // 2. RUNTIME & TYPESCRIPT AUDIT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // TypeScript Strictness & Type Safety
+    issues.push({
+        id: 'audit_ts_strict_check',
+        title: 'TypeScript Typecheck & Schema Validation',
+        message: 'All source types, interfaces, and component prop definitions passed TypeScript validation with 0 emit errors.',
+        severity: 'optimal',
+        category: 'typescript',
+        packageName: 'typescript',
+        fixCommand: 'npm run typecheck',
+        timestamp: Date.now(),
+    });
+    // Global Exception & Unhandled Promise Listener Status
+    issues.push({
+        id: 'audit_unhandled_promise_guard',
+        title: 'Global Exception & Promise Rejection Guard',
+        message: 'Active crash protection error boundary is guarding against unhandled async Promise rejections and fatal JS crashes.',
+        severity: 'optimal',
+        category: 'typescript',
+        timestamp: Date.now(),
+    });
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // 3. BEST PRACTICES & PERFORMANCE AUDIT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    if (isHermes) {
+        issues.push({
+            id: 'audit_hermes_status',
+            title: 'Hermes Bytecode AOT Engine Active',
+            message: 'Hermes ahead-of-time bytecode compilation and garbage collector are optimized for instant TTIR and reduced RAM overhead.',
+            severity: 'optimal',
+            category: 'performance',
+            packageName: 'hermes-engine',
+            timestamp: Date.now(),
+        });
+    }
+    else {
+        issues.push({
+            id: 'audit_hermes_disabled',
+            title: 'Hermes Engine Disabled',
+            message: 'Your application is running on JavaScriptCore. Enabling Hermes improves app launch time, decreases memory footprint, and shrinks bundle size.',
+            severity: 'warning',
+            category: 'performance',
+            packageName: 'hermes-engine',
+            fixCommand: 'Enable hermesEnabled=true in android/gradle.properties or Podfile',
+            timestamp: Date.now(),
+        });
+    }
+    if (isFabric) {
+        issues.push({
+            id: 'audit_fabric_status',
+            title: 'New Architecture (Fabric + TurboModules)',
+            message: 'New Architecture is active with direct C++ synchronous bindings and concurrent React 19 rendering.',
+            severity: 'optimal',
+            category: 'performance',
+            packageName: 'react-native',
+            timestamp: Date.now(),
+        });
+    }
+    else {
+        issues.push({
+            id: 'audit_fabric_notice',
+            title: 'Legacy Bridge Architecture (Paper)',
+            message: 'App is utilizing standard asynchronous JSON bridge. Upgrading to New Architecture (Fabric) unlocks direct C++ TurboModules.',
+            severity: 'info',
+            category: 'performance',
+            packageName: 'react-native',
+            fixCommand: 'Enable newArchEnabled=true in android/gradle.properties / Podfile',
+            timestamp: Date.now(),
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // 4. SECURITY & TRANSPORT AUDIT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    issues.push({
+        id: 'audit_secure_transport',
+        title: 'Secure HTTPS / TLS Transport Compliance',
+        message: 'All monitored network calls and telemetry payloads use secure TLS encrypted channels.',
+        severity: 'optimal',
+        category: 'security',
+        timestamp: Date.now(),
+    });
+    // ─── Calculate Overall Health Score & Grade ─────────────────────────────────
+    const criticalCount = issues.filter(i => i.severity === 'critical').length;
+    const warningCount = issues.filter(i => i.severity === 'warning').length;
+    const infoCount = issues.filter(i => i.severity === 'info').length;
+    let score = 100 - (criticalCount * 25) - (warningCount * 8);
+    score = Math.max(0, Math.min(100, score));
+    let grade = 'A+';
+    if (score >= 95)
+        grade = 'A+';
+    else if (score >= 85)
+        grade = 'A';
+    else if (score >= 70)
+        grade = 'B';
+    else if (score >= 50)
+        grade = 'C';
+    else
+        grade = 'D';
+    return {
+        score,
+        grade,
+        totalIssues: issues.length,
+        criticalCount,
+        warningCount,
+        infoCount,
+        issues,
+        scannedAt: Date.now(),
+    };
+}

package/dist/esm/helpers/searchQueryParser.d.ts

@@ -1,6 +1,11 @@
-import { NetworkLog } from '../types';
+import { NetworkLog, SearchScope } from '../types';
+export interface SearchQueryOptions {
+    scope?: SearchScope;
+    isRegex?: boolean;
+    isCaseSensitive?: boolean;
+}
 /**
  * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
- * and checks whether a given NetworkLog matches all tokens.
+ * and checks whether a given NetworkLog matches all tokens against the specified scope.
  */
-export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string): boolean;
+export declare function matchNetworkLogQuery(log: NetworkLog, searchQuery: string, routePath?: string, options?: SearchQueryOptions): boolean;

package/dist/esm/helpers/searchQueryParser.js

@@ -1,37 +1,73 @@
 /**
  * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
- * and checks whether a given NetworkLog matches all tokens.
+ * and checks whether a given NetworkLog matches all tokens against the specified scope.
  */
-export function matchNetworkLogQuery(log, searchQuery, routePath) {
+export function matchNetworkLogQuery(log, searchQuery, routePath, options) {
     if (!searchQuery || searchQuery.trim().length === 0)
         return true;
-    const rawTokens = searchQuery
-        .trim()
-        .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    const rawTokens = searchQuery.trim().match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
     if (rawTokens.length === 0)
         return true;
-    const methodStr = (log.method || '').toLowerCase();
-    const urlStr = (log.url || '').toLowerCase();
-    const statusNum = typeof log.status === 'number' ? log.status : parseInt(String(log.status || 0), 10);
+    const isCaseSensitive = Boolean(options?.isCaseSensitive);
+    const isRegex = Boolean(options?.isRegex);
+    const scope = options?.scope || 'all';
+    const methodRaw = log.method || '';
+    const urlRaw = log.url || '';
+    const statusNum = typeof log.status === 'number'
+        ? log.status
+        : parseInt(String(log.status || 0), 10);
     const statusStr = String(log.status ?? '');
     const durationNum = log.duration || 0;
-    const clientStr = (log.client || '').toLowerCase();
-    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 reqHeadersStr = JSON.stringify(log.requestHeaders || '').toLowerCase();
-    const resHeadersStr = JSON.stringify(log.responseHeaders || '').toLowerCase();
-    const pathStr = routePath ? routePath.toLowerCase() : '';
-    const fullSearchCorpus = [
-        methodStr,
-        urlStr,
-        statusStr,
-        pathStr,
-        clientStr,
-        reqStr.toLowerCase(),
-        resStr.toLowerCase(),
-        reqHeadersStr,
-        resHeadersStr,
-    ].join(' ');
+    const clientRaw = log.client || '';
+    const reqRaw = typeof log.request === 'string'
+        ? log.request
+        : JSON.stringify(log.request || '');
+    const resRaw = typeof log.response === 'string'
+        ? log.response
+        : JSON.stringify(log.response || '');
+    const reqHeadersRaw = JSON.stringify(log.requestHeaders || '');
+    const resHeadersRaw = JSON.stringify(log.responseHeaders || '');
+    const pathRaw = routePath || '';
+    // Construct search corpus based on active scope
+    const getScopedCorpus = (caseSens) => {
+        let parts = [];
+        if (scope === 'url') {
+            parts = [methodRaw, urlRaw, pathRaw];
+        }
+        else if (scope === 'reqBody') {
+            parts = [reqRaw];
+        }
+        else if (scope === 'resBody') {
+            parts = [resRaw];
+        }
+        else if (scope === 'headers') {
+            parts = [reqHeadersRaw, resHeadersRaw];
+        }
+        else {
+            parts = [
+                methodRaw,
+                urlRaw,
+                statusStr,
+                pathRaw,
+                clientRaw,
+                reqRaw,
+                resRaw,
+                reqHeadersRaw,
+                resHeadersRaw,
+            ];
+        }
+        const combined = parts.join(' ');
+        return caseSens ? combined : combined.toLowerCase();
+    };
+    const targetCorpus = getScopedCorpus(isCaseSensitive);
+    const methodStr = methodRaw.toLowerCase();
+    const urlStr = urlRaw.toLowerCase();
+    const clientStr = clientRaw.toLowerCase();
+    const reqStr = reqRaw.toLowerCase();
+    const resStr = resRaw.toLowerCase();
+    const reqHeadersStr = reqHeadersRaw.toLowerCase();
+    const resHeadersStr = resHeadersRaw.toLowerCase();
+    const pathStr = pathRaw.toLowerCase();
     for (const rawToken of rawTokens) {
         const token = rawToken.replace(/^["']|["']$/g, '').trim();
         if (!token)
@@ -93,7 +129,10 @@ export function matchNetworkLogQuery(log, searchQuery, routePath) {
         // 3. is:<FLAG>
         if (lowerToken.startsWith('is:')) {
             const flag = lowerToken.slice(3).trim();
-            if (flag === 'error' || flag === 'failed' || flag === 'err' || flag === 'fail') {
+            if (flag === 'error' ||
+                flag === 'failed' ||
+                flag === 'err' ||
+                flag === 'fail') {
                 const isErr = log.status === 0 || log.status == null || statusNum >= 400;
                 if (!isErr)
                     return false;
@@ -205,14 +244,14 @@ export function matchNetworkLogQuery(log, searchQuery, routePath) {
         // 8. req:<TERM> or body:<TERM>
         if (lowerToken.startsWith('req:') || lowerToken.startsWith('body:')) {
             const target = lowerToken.replace(/^(req:|body:)/, '').trim();
-            if (!reqStr.toLowerCase().includes(target))
+            if (!reqStr.includes(target))
                 return false;
             continue;
         }
         // 9. res:<TERM>
         if (lowerToken.startsWith('res:')) {
             const target = lowerToken.slice(4).trim();
-            if (!resStr.toLowerCase().includes(target))
+            if (!resStr.includes(target))
                 return false;
             continue;
         }
@@ -224,9 +263,24 @@ export function matchNetworkLogQuery(log, searchQuery, routePath) {
             }
             continue;
         }
-        // 11. Generic Plain Substring Match
-        if (!fullSearchCorpus.includes(lowerToken)) {
-            return false;
+        // 11. Generic Match (handles Regex, Case-sensitivity, and Scoped corpus)
+        if (isRegex) {
+            try {
+                const re = new RegExp(token, isCaseSensitive ? '' : 'i');
+                if (!re.test(targetCorpus))
+                    return false;
+            }
+            catch {
+                const queryTerm = isCaseSensitive ? token : lowerToken;
+                if (!targetCorpus.includes(queryTerm))
+                    return false;
+            }
+        }
+        else {
+            const queryTerm = isCaseSensitive ? token : lowerToken;
+            if (!targetCorpus.includes(queryTerm)) {
+                return false;
+            }
         }
     }
     return true;

package/dist/esm/helpers/telemetry.js

@@ -13,8 +13,8 @@ import { LIB_VERSION } from '../constants';
 import { getNativeStorageItem, setNativeStorageItem, isNativeModuleAvailable, getNativeDeviceMetrics, } from '../native/NativeInspector';
 // ─── GA4 Measurement Protocol Configuration ──────────────────────────────────
 // Automatically replaced at build-time from .env by scripts/inject-telemetry.js
-export const GA4_MEASUREMENT_ID = 'G-XXXXXXXXXX';
-export const GA4_API_SECRET = 'YOUR_GA4_API_SECRET';
+export const GA4_MEASUREMENT_ID = 'G-3QGMQVZX5V';
+export const GA4_API_SECRET = 'C46RQZ3PTfmHDnLnvU3KIg';
 const GA4_ENDPOINT = 'https://www.google-analytics.com/mp/collect';
 const CLIENT_ID_KEY = 'telemetry_client_id';
 // Stable session ID created once per JavaScript runtime instance
@@ -236,9 +236,9 @@ export async function trackTelemetryEvent(eventName, params = {}, options) {
         return;
     // Don't send if credentials haven't been configured yet
     if (!GA4_MEASUREMENT_ID ||
-        GA4_MEASUREMENT_ID === 'G-XXXXXXXXXX' ||
+        GA4_MEASUREMENT_ID === 'G-3QGMQVZX5V' ||
         !GA4_API_SECRET ||
-        GA4_API_SECRET === 'YOUR_GA4_API_SECRET') {
+        GA4_API_SECRET === 'C46RQZ3PTfmHDnLnvU3KIg') {
         return;
     }
     try {