fix(runtime,jest,bridge): improve console forwarding types and add utilities

- Add ConsoleEvent/ConsoleLevel types to BridgeEvents union in bridge package
- Remove type assertions in factory.ts now that proper types exist
- Add proper generic constraints for Harness.on/off methods
- Extract shared batchedUpdate utility to avoid code duplication
- Add resetRenderState helper for common state reset pattern
- Add rate limiting for console forwarding (100 msgs/sec)
- Preserve Error details (stack/message) in forwarded console output
- Fix %d placeholder to use Number() instead of parseInt for decimals

Author: bheemreddy-samsara

packages/bridge/src/shared.ts

@@ -4,6 +4,7 @@ import type {
 } from './shared/test-runner.js';
 import type { TestCollectorEvents } from './shared/test-collector.js';
 import type { BundlerEvents } from './shared/bundler.js';
+import type { ConsoleEvent } from './shared/console.js';
 import type { HarnessPlatform } from '@react-native-harness/platforms';
 
 export type FileReference = {
@@ -103,6 +104,7 @@ export type {
   SetupFileBundlingFailedEvent,
   BundlerEvents,
 } from './shared/bundler.js';
+export type { ConsoleEvent, ConsoleLevel } from './shared/console.js';
 
 export type DeviceDescriptor = {
   platform: 'ios' | 'android' | 'vega';
@@ -114,7 +116,8 @@ export type DeviceDescriptor = {
 export type BridgeEvents =
   | TestCollectorEvents
   | TestRunnerEvents
-  | BundlerEvents;
+  | BundlerEvents
+  | ConsoleEvent;
 
 export type BridgeEventsMap = {
   [K in BridgeEvents['type']]: (

packages/bridge/src/shared/console.ts

@@ -0,0 +1,8 @@
+export type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+
+export type ConsoleEvent = {
+  type: 'console';
+  level: ConsoleLevel;
+  args: string[];
+  timestamp: number;
+};

packages/jest/src/harness.ts

@@ -1,6 +1,7 @@
 import {
   getBridgeServer,
   BridgeServer,
+  BridgeServerEvents,
 } from '@react-native-harness/bridge/server';
 import {
   HarnessContext,
@@ -31,9 +32,14 @@ export type Harness = {
   restart: () => Promise<void>;
   dispose: () => Promise<void>;
   crashMonitor: CrashMonitor;
-  // Expose bridge events for console forwarding
-  on: (event: string, handler: (...args: unknown[]) => void) => void;
-  off: (event: string, handler: (...args: unknown[]) => void) => void;
+  on: <T extends keyof BridgeServerEvents>(
+    event: T,
+    handler: BridgeServerEvents[T]
+  ) => void;
+  off: <T extends keyof BridgeServerEvents>(
+    event: T,
+    handler: BridgeServerEvents[T]
+  ) => void;
 };
 
 export const waitForAppReady = async (options: {
@@ -208,11 +214,8 @@ const getHarnessInternal = async (
     restart,
     dispose,
     crashMonitor,
-    // Expose bridge events for console forwarding
-    on: (event: string, handler: (...args: unknown[]) => void) =>
-      serverBridge.on(event as 'event', handler),
-    off: (event: string, handler: (...args: unknown[]) => void) =>
-      serverBridge.off(event as 'event', handler),
+    on: (event, handler) => serverBridge.on(event, handler),
+    off: (event, handler) => serverBridge.off(event, handler),
   };
 };
 

packages/jest/src/index.ts

@@ -19,13 +19,7 @@ import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
 import { NativeCrashError } from './errors.js';
-
-type ConsoleEvent = {
-  type: 'console';
-  level: 'log' | 'warn' | 'error' | 'info' | 'debug';
-  args: string[];
-  timestamp: number;
-};
+import { ConsoleEvent } from '@react-native-harness/bridge';
 
 // Printf-style string interpolation for console messages
 const formatConsoleMessage = (args: string[]): string => {
@@ -43,6 +37,7 @@ const formatConsoleMessage = (args: string[]): string => {
       case '%s':
         return String(arg);
       case '%d':
+        return String(Number(arg));
       case '%i':
         return String(parseInt(String(arg), 10));
       case '%o':

packages/runtime/src/client/factory.ts

@@ -3,29 +3,26 @@ import type {
   TestCollectorEvents,
   BundlerEvents,
   TestExecutionOptions,
+  ConsoleLevel,
+  ConsoleEvent,
 } from '@react-native-harness/bridge';
 import { getBridgeClient } from '@react-native-harness/bridge/client';
 import { store } from '../ui/state.js';
 import { getTestRunner, TestRunner } from '../runner/index.js';
 import { getTestCollector, TestCollector } from '../collector/index.js';
 import { combineEventEmitters, EventEmitter } from '../utils/emitter.js';
+import { createRateLimiter } from '../utils/rateLimiter.js';
 import { getWSServer } from './getWSServer.js';
 import { getBundler, evaluateModule, Bundler } from '../bundler/index.js';
 import { markTestsAsSkippedByName } from '../filtering/index.js';
 import { setup } from '../render/setup.js';
 import { runSetupFiles } from './setup-files.js';
 import { setClient } from './store.js';
 
-type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
-type EmitEventFn = (
-  type: string,
-  data: {
-    type: string;
-    level: ConsoleLevel;
-    args: string[];
-    timestamp: number;
-  }
-) => void;
+type EmitEventFn = (type: ConsoleEvent['type'], data: ConsoleEvent) => void;
+
+// Rate limit: 100 messages per second
+const CONSOLE_RATE_LIMIT = { maxCalls: 100, windowMs: 1000 };
 
 // Console forwarding setup - intercepts console calls and emits events to host
 const setupConsoleForwarding = (emitEvent: EmitEventFn): (() => void) => {
@@ -37,19 +34,44 @@ const setupConsoleForwarding = (emitEvent: EmitEventFn): (() => void) => {
     debug: console.debug,
   };
 
+  const rateLimiter = createRateLimiter(CONSOLE_RATE_LIMIT);
+  let droppedCount = 0;
+  let lastDropWarningTime = 0;
+
   const createForwarder =
     (level: ConsoleLevel) =>
     (...args: unknown[]) => {
       // Call original console method
       originalConsole[level](...args);
+
+      // Check rate limit before forwarding
+      if (!rateLimiter.tryAcquire()) {
+        droppedCount++;
+        // Log a warning at most once per second about dropped messages
+        const now = Date.now();
+        if (now - lastDropWarningTime > 1000) {
+          lastDropWarningTime = now;
+          originalConsole.warn(
+            `[Harness] Console rate limit exceeded, ${droppedCount} messages dropped`
+          );
+        }
+        return;
+      }
+
       // Forward to host via bridge
       try {
         emitEvent('console', {
           type: 'console',
           level,
           args: args.map((arg) => {
             try {
-              return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
+              if (arg instanceof Error) {
+                return arg.stack ?? `${arg.name}: ${arg.message}`;
+              }
+              if (typeof arg === 'object' && arg !== null) {
+                return JSON.stringify(arg);
+              }
+              return String(arg);
             } catch {
               return String(arg);
             }
@@ -70,6 +92,7 @@ const setupConsoleForwarding = (emitEvent: EmitEventFn): (() => void) => {
   // Return cleanup function to restore original console
   return () => {
     Object.assign(console, originalConsole);
+    rateLimiter.reset();
   };
 };
 
@@ -116,11 +139,7 @@ export const getClient = async () => {
 
       // Setup console forwarding to emit console events to host
       cleanupConsole = setupConsoleForwarding((type, data) => {
-        // Use type assertion since 'console' is a new event type not in the current type definitions
-        (client.rpc.emitEvent as (type: string, data: unknown) => void)(
-          type,
-          data
-        );
+        client.rpc.emitEvent(type, data);
       });
 
       await runSetupFiles({

packages/runtime/src/render/cleanup.ts

@@ -1,16 +1,5 @@
-import { unstable_batchedUpdates } from 'react-native';
-import { store } from '../ui/state.js';
+import { resetRenderState } from './utils.js';
 
 export const cleanup = (): void => {
-  const doCleanup = () => {
-    store.getState().setRenderedElement(null);
-    store.getState().setOnLayoutCallback(null);
-    store.getState().setOnRenderCallback(null);
-  };
-
-  if (unstable_batchedUpdates) {
-    unstable_batchedUpdates(doCleanup);
-  } else {
-    doCleanup();
-  }
+  resetRenderState();
 };

packages/runtime/src/render/index.ts

@@ -1,6 +1,7 @@
 import React from 'react';
-import { unstable_batchedUpdates } from 'react-native';
 import { store } from '../ui/state.js';
+import { batchedUpdate } from '../utils/batchedUpdate.js';
+import { resetRenderState } from './utils.js';
 import type { RenderResult, RenderOptions } from './types.js';
 
 const wrapElement = (
@@ -13,15 +14,6 @@ const wrapElement = (
   return React.createElement(wrapper, { children: element });
 };
 
-// Helper to batch state updates to avoid act() warnings
-const batchedUpdate = (fn: () => void): void => {
-  if (unstable_batchedUpdates) {
-    unstable_batchedUpdates(fn);
-  } else {
-    fn();
-  }
-};
-
 export const render = async (
   element: React.ReactElement,
   options: RenderOptions = {}
@@ -30,11 +22,7 @@ export const render = async (
 
   // If an element is already rendered, unmount it first
   if (store.getState().renderedElement !== null) {
-    batchedUpdate(() => {
-      store.getState().setRenderedElement(null);
-      store.getState().setOnLayoutCallback(null);
-      store.getState().setOnRenderCallback(null);
-    });
+    resetRenderState();
   }
 
   // Create a promise that resolves when the element is rendered.
@@ -102,12 +90,7 @@ export const render = async (
     if (store.getState().renderedElement === null) {
       return;
     }
-
-    batchedUpdate(() => {
-      store.getState().setRenderedElement(null);
-      store.getState().setOnLayoutCallback(null);
-      store.getState().setOnRenderCallback(null);
-    });
+    resetRenderState();
   };
 
   return {

packages/runtime/src/render/utils.ts

@@ -0,0 +1,14 @@
+import { store } from '../ui/state.js';
+import { batchedUpdate } from '../utils/batchedUpdate.js';
+
+/**
+ * Resets render-related state in a batched update.
+ * Clears the rendered element and associated callbacks.
+ */
+export const resetRenderState = (): void => {
+  batchedUpdate(() => {
+    store.getState().setRenderedElement(null);
+    store.getState().setOnLayoutCallback(null);
+    store.getState().setOnRenderCallback(null);
+  });
+};

packages/runtime/src/utils/batchedUpdate.ts

@@ -0,0 +1,13 @@
+import { unstable_batchedUpdates } from 'react-native';
+
+/**
+ * Batches state updates to avoid act() warnings in React Native.
+ * Falls back to direct execution if unstable_batchedUpdates is unavailable.
+ */
+export const batchedUpdate = (fn: () => void): void => {
+  if (unstable_batchedUpdates) {
+    unstable_batchedUpdates(fn);
+  } else {
+    fn();
+  }
+};

packages/runtime/src/utils/rateLimiter.ts

@@ -0,0 +1,45 @@
+export type RateLimiterOptions = {
+  /** Maximum number of calls allowed per window */
+  maxCalls: number;
+  /** Time window in milliseconds */
+  windowMs: number;
+};
+
+export type RateLimiter = {
+  /** Returns true if the call is allowed, false if rate limited */
+  tryAcquire: () => boolean;
+  /** Reset the rate limiter state */
+  reset: () => void;
+};
+
+/**
+ * Creates a simple sliding window rate limiter.
+ * Tracks call timestamps and allows calls only if within the limit.
+ */
+export const createRateLimiter = (options: RateLimiterOptions): RateLimiter => {
+  const { maxCalls, windowMs } = options;
+  const timestamps: number[] = [];
+
+  const tryAcquire = (): boolean => {
+    const now = Date.now();
+    const windowStart = now - windowMs;
+
+    // Remove timestamps outside the window
+    while (timestamps.length > 0 && timestamps[0] <= windowStart) {
+      timestamps.shift();
+    }
+
+    if (timestamps.length >= maxCalls) {
+      return false;
+    }
+
+    timestamps.push(now);
+    return true;
+  };
+
+  const reset = (): void => {
+    timestamps.length = 0;
+  };
+
+  return { tryAcquire, reset };
+};