@mobileai/react-native 0.9.18 → 0.9.20

package/lib/module/support/reportIssueTool.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import { ENDPOINTS } from "../config/endpoints.js";
+import { getDeviceId } from "../services/telemetry/device.js";
+import { logger } from "../utils/logger.js";
+const MOBILEAI_HOST = ENDPOINTS.escalation;
+const DEFAULT_STATUS_MESSAGES = {
+  acknowledged: 'We’ve logged your issue and are reviewing it.',
+  investigating: 'We’re checking this and will update you if needed.',
+  answered: 'We reviewed your issue and confirmed what happened.',
+  resolved: 'We found the issue and applied a fix.',
+  escalated: 'A human support agent will reply here shortly.'
+};
+export function createReportIssueTool({
+  analyticsKey,
+  getCurrentScreen,
+  getHistory,
+  getScreenFlow,
+  userContext
+}) {
+  if (!analyticsKey) return null;
+  return {
+    name: 'report_issue',
+    description: 'Create an AI-verified reported issue when the complaint is supported by app evidence you can already see or infer from the current UI flow. ' + 'Use this for verified late orders, overcharges, broken subscription states, missing loyalty points, gift failures, notification mismatches, or account friction. ' + 'Do not use it for anger alone. If you need customer follow-up, a sensitive explanation, or a human was explicitly requested, use escalate_to_human instead.',
+    parameters: {
+      issueType: {
+        type: 'string',
+        description: 'Short issue type like late_order, overcharge, loyalty_points_missing, notification_mismatch',
+        required: true
+      },
+      complaintSummary: {
+        type: 'string',
+        description: 'One-sentence summary of the customer problem',
+        required: true
+      },
+      verificationStatus: {
+        type: 'string',
+        description: 'verified, likely_verified, or unverified',
+        required: true
+      },
+      severity: {
+        type: 'string',
+        description: 'low, medium, high, or critical',
+        required: true
+      },
+      confidence: {
+        type: 'number',
+        description: 'Confidence between 0 and 1',
+        required: false
+      },
+      evidenceSummary: {
+        type: 'string',
+        description: 'What app evidence supports the issue',
+        required: true
+      },
+      aiSummary: {
+        type: 'string',
+        description: 'Short operator-facing summary of what you checked and found',
+        required: true
+      },
+      metadata: {
+        type: 'string',
+        description: 'Optional JSON string with extra fields like recommendedAction, sourceScreens, orderId, chargeId, subscriptionId, giftId, customerStatus, customerMessage, confidence',
+        required: false
+      }
+    },
+    execute: async args => {
+      let metadata = {};
+      if (typeof args.metadata === 'string' && args.metadata.trim().length > 0) {
+        try {
+          const parsed = JSON.parse(args.metadata);
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            metadata = parsed;
+          }
+        } catch (error) {
+          logger.warn('ReportIssue', `Invalid metadata JSON: ${error.message}`);
+        }
+      }
+      const status = typeof metadata.customerStatus === 'string' && metadata.customerStatus in DEFAULT_STATUS_MESSAGES ? metadata.customerStatus : 'acknowledged';
+      const customerMessage = typeof metadata.customerMessage === 'string' && metadata.customerMessage.trim().length > 0 ? metadata.customerMessage.trim() : DEFAULT_STATUS_MESSAGES[status];
+      const sourceScreens = typeof metadata.sourceScreens === 'string' && metadata.sourceScreens.trim().length > 0 ? metadata.sourceScreens.split(',').map(screen => screen.trim()).filter(Boolean) : [getCurrentScreen()];
+      try {
+        const res = await fetch(`${MOBILEAI_HOST}/api/v1/reported-issues`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            analyticsKey,
+            issueType: args.issueType,
+            complaintSummary: args.complaintSummary,
+            verificationStatus: args.verificationStatus,
+            severity: args.severity,
+            confidence: typeof metadata.confidence === 'number' ? metadata.confidence : undefined,
+            screen: getCurrentScreen(),
+            evidenceSummary: args.evidenceSummary,
+            aiSummary: args.aiSummary,
+            recommendedAction: typeof metadata.recommendedAction === 'string' ? metadata.recommendedAction : undefined,
+            sourceScreens,
+            screenFlow: getScreenFlow?.() ?? [],
+            userContext,
+            deviceId: getDeviceId(),
+            orderId: typeof metadata.orderId === 'string' ? metadata.orderId : undefined,
+            chargeId: typeof metadata.chargeId === 'string' ? metadata.chargeId : undefined,
+            subscriptionId: typeof metadata.subscriptionId === 'string' ? metadata.subscriptionId : undefined,
+            giftId: typeof metadata.giftId === 'string' ? metadata.giftId : undefined,
+            customerStatus: status,
+            customerMessage,
+            history: getHistory().slice(-10)
+          })
+        });
+        if (!res.ok) {
+          logger.warn('ReportIssue', `Failed to create reported issue: ${res.status}`);
+          return customerMessage;
+        }
+        const data = await res.json();
+        logger.info('ReportIssue', 'Created reported issue', data.issueId);
+        const firstHistoryId = Array.isArray(data.history) && data.history[0] && typeof data.history[0].id === 'string' ? data.history[0].id : '';
+        return `ISSUE_REPORTED:${String(data.issueId)}:${firstHistoryId}:${customerMessage}`;
+      } catch (error) {
+        logger.error('ReportIssue', 'Network error:', error.message);
+        return customerMessage;
+      }
+    }
+  };
+}
+//# sourceMappingURL=reportIssueTool.js.map

package/lib/module/support/supportPrompt.js

@@ -17,16 +17,73 @@ export function buildSupportPrompt(config) {
   parts.push(`
 ## Support Mode Active
 
-You are a helpful customer support assistant. Your primary goal is to resolve the user's issue quickly and empathetically.
+You are a helpful customer support assistant representing the company. Your primary goal is to RESOLVE the user's issue through empathetic conversation. App navigation is a tool you USE when needed, not the first thing you propose.
 
-### Behavior Guidelines
-- Greet the user warmly and acknowledge their issue
-- Ask clarifying questions when the user's request is ambiguous
-- Provide step-by-step guidance when helping with app features
-- Use the app's UI tools to demonstrate solutions visually (tap, navigate, type)
-- After resolving, confirm with the user that their issue is fixed
-- Stay focused on the user's current issue — complete one task before moving to another
-`);
+### Identity & Context
+Adopt the persona of a dedicated human customer support team member. Speak on behalf of the company as an organization with human operational timelines.
+
+Base all discussions regarding processing, reviews, resolutions, and response expectations on standard operational business timelines. Treat the conversational context holistically—assume any user questions about "you" or "when you will reply" refer to the company's human support staff processing their real-world request. Express empathy naturally, and assure the user that the operational team is handling their ticket promptly.
+
+### Support Resolution Protocol (HEARD)
+Follow this sequence. Exhaust each level before moving to the next:
+
+1. HEAR: Listen actively. Paraphrase the problem back to confirm you understand. Ask specific
+   clarifying questions (which order? when? what happened exactly?).
+
+2. EMPATHIZE: Acknowledge the user's feelings with sincerity. Use their name if available.
+   Say "I understand how frustrating this must be" — not "I see you have an issue."
+   Take responsibility where appropriate.
+
+3. ANSWER: Search the knowledge base (query_knowledge) for relevant policies, FAQs, and procedures.
+   Provide information and potential solutions through conversation.
+   Many issues can be fully resolved here without any app interaction.
+
+4. RESOLVE:
+   - If the issue is resolved through conversation → confirm with the user and call done().
+   - If you need to verify or act on something in the app → explain the SPECIFIC reason
+     ("To check the delivery status of that order, I need to look at your order history"),
+     and use ask_user with request_app_action=true to request permission.
+     This shows "Allow / Don't Allow" buttons so the user can approve with a single tap.
+   - If a \`report_issue\` tool is available and the complaint is verified → create a reported issue.
+
+5. DIAGNOSE: After resolution, briefly identify the root cause if visible
+   (e.g. "It looks like the delivery partner marked it as delivered prematurely").
+   Ask the user if the issue is fully resolved before calling done().`);
+  parts.push(`
+### Consent and Liability Guard
+- Treat money movement, subscription cancellation, deletion, final submission, and account/security changes as high-risk actions.
+- For those actions, explicit user consent immediately before the final commit is mandatory.
+- The user's earlier request, general frustration, or approval of your investigation plan does NOT count as final consent for the irreversible step.
+- Say exactly what you are about to do in plain language, including the amount, plan, or effect when visible.
+- If explicit final consent is missing, stop and ask before taking the action.`);
+  parts.push(`
+### Reported Issue Policy
+- If app evidence clearly supports the complaint, create a reported issue with the \`report_issue\` tool before you finish.
+- Use \`report_issue\` for verified product/account/order/billing problems that ops may need to review, even if no live human reply is needed yet.
+- Anger alone is NOT enough to report or escalate.
+- Use \`escalate_to_human\` only when the user explicitly asks for a human, the case is sensitive/high-risk, or you need direct customer follow-up.`);
+
+  // Progress Communication
+  parts.push(`
+### Progress Communication
+When executing a multi-step resolution, you must communicate your progress to keep the user informed.
+- Do NOT execute more than 2 tools in silence.
+- Use the 'ask_user' tool to say phrases like "I am checking your account details now..." or "Just a moment while I pull up that information."
+- Never leave the user waiting in silence during complex operations.`);
+
+  // Agent Persona
+  if (config.persona) {
+    const {
+      agentName,
+      tone,
+      signOff
+    } = config.persona;
+    let personaStr = `\n### AI Persona & Tone\n`;
+    if (agentName) personaStr += `- Your name is ${agentName}. Introduce yourself if appropriate.\n`;
+    if (tone) personaStr += `- Maintain a ${tone} tone throughout the conversation.\n`;
+    if (signOff) personaStr += `- When resolving an issue, sign off with: "${signOff}".\n`;
+    parts.push(personaStr);
+  }
 
   // Custom system context from the consumer
   if (config.systemContext) {
@@ -42,6 +99,17 @@ You are a helpful customer support assistant. Your primary goal is to resolve th
   if (config.businessHours) {
     parts.push(`### Business Hours\n` + `The support team operates in timezone: ${config.businessHours.timezone}.\n` + `If outside business hours, inform the user and offer to help with what you can.\n`);
   }
+
+  // WOW Actions
+  if (config.wowActions?.length) {
+    let wowStr = `\n### WOW Actions (Surprise & Delight)\n`;
+    wowStr += `You have special tools ("WOW Actions") available to turn a frustrating experience into a positive one.\n`;
+    wowStr += `Only use these when the user is frustrated AND you have fully resolved their core issue.\n`;
+    config.wowActions.forEach(action => {
+      wowStr += `- Tool \`${action.name}\`: ${action.triggerHint}\n`;
+    });
+    parts.push(wowStr);
+  }
   return parts.join('\n');
 }
 //# sourceMappingURL=supportPrompt.js.map

package/lib/module/tools/guideTool.js

@@ -2,6 +2,7 @@
 
 import { DeviceEventEmitter } from 'react-native';
 import { logger } from "../utils/logger.js";
+import { getStateNode } from "../core/FiberAdapter.js";
 export function createGuideTool(context) {
   return {
     name: 'guide_user',
@@ -42,7 +43,7 @@ export function createGuideTool(context) {
         });
         return `✅ Highlighted element ${index} ("${element.label}") with message: "${args.message}"`;
       }
-      const stateNode = element.fiberNode?.stateNode;
+      const stateNode = getStateNode(element.fiberNode);
       if (!stateNode || typeof stateNode.measure !== 'function') {
         return `❌ Element at index ${index} (${element.label}) cannot be highlighted because its layout position cannot be measured.`;
       }

package/lib/module/tools/longPressTool.js

@@ -12,6 +12,7 @@
  */
 
 import { walkFiberTree } from "../core/FiberTreeWalker.js";
+import { getParent, getProps } from "../core/FiberAdapter.js";
 export function createLongPressTool(context) {
   return {
     name: 'long_press',
@@ -44,10 +45,10 @@ export function createLongPressTool(context) {
       }
 
       // Strategy 2: Bubble up fiber tree
-      let fiber = element.fiberNode?.return;
+      let fiber = getParent(element.fiberNode);
       let bubbleDepth = 0;
       while (fiber && bubbleDepth < 5) {
-        const parentProps = fiber.memoizedProps || {};
+        const parentProps = getProps(fiber);
         if (parentProps.onLongPress && typeof parentProps.onLongPress === 'function') {
           try {
             parentProps.onLongPress();
@@ -57,7 +58,7 @@ export function createLongPressTool(context) {
             return `❌ Error long-pressing parent of [${args.index}]: ${error.message}`;
           }
         }
-        fiber = fiber.return;
+        fiber = getParent(fiber);
         bubbleDepth++;
       }
       return `❌ Element [${args.index}] "${element.label}" has no long-press handler. Try using tap instead.`;

package/lib/module/tools/pickerTool.js

@@ -10,6 +10,7 @@
  */
 
 import { walkFiberTree } from "../core/FiberTreeWalker.js";
+import { getChild, getSibling, getProps } from "../core/FiberAdapter.js";
 /**
  * Extract available options from a picker element's props.
  * Handles multiple picker libraries:
@@ -54,17 +55,18 @@ function extractPickerOptions(element) {
 
   // Pattern 3: Fiber children (RN Picker with Picker.Item children)
   const fiberNode = element.fiberNode;
-  if (fiberNode?.child) {
-    let child = fiberNode.child;
+  const firstChild = getChild(fiberNode);
+  if (firstChild) {
+    let child = firstChild;
     while (child) {
-      const childProps = child.memoizedProps || {};
+      const childProps = getProps(child);
       if (childProps.label !== undefined && childProps.value !== undefined) {
         options.push({
           label: String(childProps.label),
           value: childProps.value
         });
       }
-      child = child.sibling;
+      child = getSibling(child);
     }
   }
   return options;

package/lib/module/tools/tapTool.js

@@ -14,6 +14,8 @@
  */
 
 import { walkFiberTree } from "../core/FiberTreeWalker.js";
+import { getParent, getProps } from "../core/FiberAdapter.js";
+import { dismissAlert } from "../core/NativeAlertInterceptor.js";
 export function createTapTool(context) {
   return {
     name: 'tap',
@@ -37,6 +39,13 @@ export function createTapTool(context) {
       const elementCountBefore = elements.length;
       const screenBefore = context.getCurrentScreenName();
 
+      // Strategy 0: Virtual elements (Native OS dialogs)
+      if (element.virtual?.kind === 'alert_button') {
+        dismissAlert(element.virtual.alertButtonIndex);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        return `✅ Tapped native alert button [${args.index}] "${element.label}" → dialog dismissed`;
+      }
+
       // Strategy 1: Switch → onValueChange
       if (element.type === 'switch' && element.props.onValueChange) {
         try {
@@ -73,10 +82,10 @@ export function createTapTool(context) {
       }
 
       // Strategy 3: Bubble up fiber tree (like RNTL's findEventHandler)
-      let fiber = element.fiberNode?.return;
+      let fiber = getParent(element.fiberNode);
       let bubbleDepth = 0;
       while (fiber && bubbleDepth < 5) {
-        const parentProps = fiber.memoizedProps || {};
+        const parentProps = getProps(fiber);
         if (parentProps.onPress && typeof parentProps.onPress === 'function') {
           try {
             parentProps.onPress();
@@ -86,7 +95,7 @@ export function createTapTool(context) {
             return `❌ Error tapping parent of [${args.index}]: ${error.message}`;
           }
         }
-        fiber = fiber.return;
+        fiber = getParent(fiber);
         bubbleDepth++;
       }
       return `❌ Element [${args.index}] "${element.label}" has no tap handler (no onPress or onValueChange found).`;

package/lib/module/tools/typeTool.js

@@ -17,11 +17,13 @@
  */
 
 import { walkFiberTree } from "../core/FiberTreeWalker.js";
+import { getChild, getSibling, getProps, getStateNode } from "../core/FiberAdapter.js";
 /** BFS through fiber children. Returns first node where predicate matches. */
 function findFiberNode(rootFiber, predicate, maxDepth = 10) {
-  if (!rootFiber?.child) return null;
+  const firstChild = getChild(rootFiber);
+  if (!firstChild) return null;
   const queue = [{
-    node: rootFiber.child,
+    node: firstChild,
     depth: 0
   }];
   while (queue.length > 0) {
@@ -31,12 +33,14 @@ function findFiberNode(rootFiber, predicate, maxDepth = 10) {
     } = queue.shift();
     if (!node || depth > maxDepth) continue;
     if (predicate(node)) return node;
-    if (node.child) queue.push({
-      node: node.child,
+    const child = getChild(node);
+    if (child) queue.push({
+      node: child,
       depth: depth + 1
     });
-    if (node.sibling) queue.push({
-      node: node.sibling,
+    const sibling = getSibling(node);
+    if (sibling) queue.push({
+      node: sibling,
       depth: depth + 1
     });
   }
@@ -88,12 +92,17 @@ export function createTypeTool(context) {
       //   b) find the native stateNode to call setNativeProps to update visual display
       if (fiberNode) {
         // Find native onChange handler (behavior-based, no tag numbers)
-        const nativeOnChangeFiber = fiberNode.memoizedProps?.onChange ? fiberNode : findFiberNode(fiberNode, n => typeof n.memoizedProps?.onChange === 'function');
+        const fiberProps = getProps(fiberNode);
+        const nativeOnChangeFiber = fiberProps?.onChange ? fiberNode : findFiberNode(fiberNode, n => typeof getProps(n)?.onChange === 'function');
 
         // Find native stateNode (host component with setNativeProps)
-        const nativeStateFiber = fiberNode.stateNode?.setNativeProps ? fiberNode : findFiberNode(fiberNode, n => n.stateNode && typeof n.stateNode.setNativeProps === 'function');
-        const onChange = nativeOnChangeFiber?.memoizedProps?.onChange;
-        const nativeInstance = nativeStateFiber?.stateNode;
+        const fiberStateNode = getStateNode(fiberNode);
+        const nativeStateFiber = fiberStateNode?.setNativeProps ? fiberNode : findFiberNode(fiberNode, n => {
+          const stateN = getStateNode(n);
+          return stateN && typeof stateN.setNativeProps === 'function';
+        });
+        const onChange = getProps(nativeOnChangeFiber)?.onChange;
+        const nativeInstance = getStateNode(nativeStateFiber);
         if (onChange || nativeInstance) {
           try {
             // Step 1: Update visual text in native view

package/lib/module/utils/logger.js

@@ -5,9 +5,150 @@
  *
  * Disabled by default. Enable via `logger.setEnabled(true)` or
  * pass `debug={true}` to the <AIAgent> component.
+ *
+ * Production logging:
+ * In release builds, console.log is invisible (no Metro terminal).
+ * When enabled, logs are routed to the native logging system:
+ * - iOS: os_log → visible in Xcode Console app (Window → Devices)
+ * - Android: Logcat → visible via `adb logcat *:S ReactNativeJS:V`
+ *
+ * This uses React Native's built-in native logging bridge, which
+ * calls through to NSLog (iOS) and android.util.Log (Android).
+ * No additional native dependencies required.
  */
 const TAG = '[AIAgent]';
+const MAX_ENTRIES = 2000;
 let enabled = false;
+const entries = [];
+const unflushedEntries = [];
+
+// ─── Native Logging Transport ──────────────────────────────────
+// Routes logs to os_log (iOS) / Logcat (Android) in release builds.
+// Uses React Native's global.nativeLoggingHook if available, which
+// is the same mechanism React Native uses internally for console.*
+// in bridgeless mode. Falls back to console.* otherwise.
+
+/**
+ * Write a message to the native logging system.
+ * In release builds without Metro, this is the only way to see logs
+ * in Xcode Console or `adb logcat`.
+ *
+ * nativeLoggingHook levels: 0=log, 1=warn, 2=error
+ */
+const LOG_LEVEL_MAP = {
+  info: 0,
+  warn: 1,
+  error: 2,
+  debug: 0
+};
+function nativeLog(level, message) {
+  try {
+    // Strategy 1: nativeLoggingHook — React Native's internal bridge to NSLog/Logcat.
+    // Present in both dev and release builds. This is what console.* ultimately
+    // calls in React Native's JS environment.
+    const hook = globalThis.nativeLoggingHook;
+    if (typeof hook === 'function') {
+      hook(message, LOG_LEVEL_MAP[level]);
+      return;
+    }
+
+    // Strategy 2: Hermes console — in Hermes release builds, console methods
+    // may still route to the native log system depending on the build config.
+    // This is a fallback if nativeLoggingHook isn't available.
+    switch (level) {
+      case 'error':
+        console.error(message);
+        break;
+      case 'warn':
+        console.warn(message);
+        break;
+      default:
+        console.log(message);
+    }
+  } catch {
+    // Silently fail — never crash the app due to logging
+  }
+}
+function formatArg(arg) {
+  if (typeof arg === 'string') return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  if (arg === null) return 'null';
+  if (arg === undefined) return 'undefined';
+  if (typeof arg !== 'object') return String(arg);
+  try {
+    // Highly performant O(1) depth-1 stringifier to prevent JS thread freezes
+    return JSON.stringify(arg, (key, value) => {
+      // Allow the root object (where key is empty string)
+      if (key === '') return value;
+      // For any nested objects/arrays, summarize them instantly without recursion
+      if (typeof value === 'object' && value !== null) {
+        if (Array.isArray(value)) return `[Array(${value.length})]`;
+        return '{...}';
+      }
+      // For primitive values (strings, numbers, booleans)
+      if (typeof value === 'string' && value.length > 200) {
+        return value.substring(0, 200) + '...';
+      }
+      return value;
+    });
+  } catch {
+    return '[unserializable]';
+  }
+}
+function formatArgs(args) {
+  return args.map(formatArg).join(' ');
+}
+function record(level, context, args) {
+  const entry = {
+    level,
+    context,
+    args,
+    timestamp: Date.now(),
+    message: `${TAG} [${context}] ${formatArgs(args)}`.trim()
+  };
+  entries.push(entry);
+
+  // Systemic anti-recursion: Do not buffer Telemetry's own logs for extraction.
+  // This physically prevents TelemetryService from harvesting its own diagnostic
+  // logs (like "Flush failed") into SDK trace dumps, eliminating infinite queue loops.
+  if (context !== 'Telemetry') {
+    unflushedEntries.push(entry);
+  }
+  if (entries.length > MAX_ENTRIES) {
+    entries.splice(0, entries.length - MAX_ENTRIES);
+  }
+  if (unflushedEntries.length > MAX_ENTRIES) {
+    unflushedEntries.splice(0, unflushedEntries.length - MAX_ENTRIES);
+  }
+  try {
+    globalThis.__MOBILEAI_LOGS__ = entries;
+  } catch {
+    // ignore global write failures
+  }
+  return entry;
+}
+
+// ─── Output helpers ────────────────────────────────────────────
+
+/** Route a log message to the appropriate output based on environment. */
+function emit(level, formattedMessage) {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    // Dev mode: use console.* (visible in Metro terminal)
+    switch (level) {
+      case 'error':
+        console.error(formattedMessage);
+        break;
+      case 'warn':
+        console.warn(formattedMessage);
+        break;
+      default:
+        console.log(formattedMessage);
+    }
+  } else {
+    // Release mode: route to native logging system (os_log / Logcat)
+    nativeLog(level, formattedMessage);
+  }
+}
 export const logger = {
   /** Enable or disable all SDK logging. */
   setEnabled: value => {
@@ -15,20 +156,48 @@ export const logger = {
   },
   /** Check if logging is enabled. */
   isEnabled: () => enabled,
+  /** Return a snapshot of recent SDK log entries. */
+  getEntries: () => [...entries],
+  /** Return recent entries as plain text lines, newest last. */
+  getRecentLines: (limit = 200) => entries.slice(-Math.max(0, limit)).map(entry => {
+    const iso = new Date(entry.timestamp).toISOString();
+    return `${iso} ${entry.message}`;
+  }),
+  /** Extract unflushed entries as plain text and clear the unflushed buffer. */
+  extractUnflushedLines: () => {
+    if (unflushedEntries.length === 0) return [];
+    const lines = unflushedEntries.map(entry => {
+      const iso = new Date(entry.timestamp).toISOString();
+      return `${iso} ${entry.message}`;
+    });
+    unflushedEntries.length = 0;
+    return lines;
+  },
+  /** Clear the in-memory SDK log history. */
+  clearEntries: () => {
+    entries.length = 0;
+    try {
+      globalThis.__MOBILEAI_LOGS__ = entries;
+    } catch {
+      // ignore global write failures
+    }
+  },
   info: (context, ...args) => {
-    if (enabled) console.log(`${TAG} [${context}]`, ...args);
+    record('info', context, args);
+    if (enabled) emit('info', `${TAG} [${context}] ${formatArgs(args)}`);
   },
   warn: (context, ...args) => {
-    if (enabled) console.warn(`${TAG} [${context}]`, ...args);
+    record('warn', context, args);
+    if (enabled) emit('warn', `${TAG} [${context}] ${formatArgs(args)}`);
   },
   error: (context, ...args) => {
+    record('error', context, args);
     // Errors always log regardless of enabled flag
-    console.error(`${TAG} [${context}]`, ...args);
+    emit('error', `${TAG} [${context}] ${formatArgs(args)}`);
   },
   debug: (context, ...args) => {
-    if (enabled && __DEV__) {
-      console.log(`${TAG} [${context}] 🐛`, ...args);
-    }
+    record('debug', context, args);
+    if (enabled) emit('debug', `${TAG} [${context}] 🐛 ${formatArgs(args)}`);
   }
 };
 //# sourceMappingURL=logger.js.map

package/lib/typescript/react-native.config.d.ts

@@ -0,0 +1,11 @@
+export namespace dependency {
+    namespace platforms {
+        namespace android {
+            let sourceDir: string;
+            let packageImportPath: string;
+            let packageInstance: string;
+        }
+        let ios: {};
+    }
+}
+//# sourceMappingURL=react-native.config.d.ts.map