@debugbundle/sdk-react-native 1.0.0 → 1.2.0

package/android/src/test/java/com/debugbundle/reactnative/DebugBundleReactNativeModuleTest.java

@@ -0,0 +1,474 @@
+package com.debugbundle.reactnative;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import com.debugbundle.android.DebugBundleConfig;
+import com.debugbundle.android.DebugBundleLogLevel;
+import com.debugbundle.android.DebugBundleRequestInfo;
+import com.debugbundle.android.DebugBundleResponseInfo;
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+public final class DebugBundleReactNativeModuleTest {
+  private ReactApplicationContext reactContext;
+  private Context applicationContext;
+  private DebugBundleReactNativeModule.NativeOperations nativeOperations;
+  private DebugBundleReactNativeModule.WritableMapFactory writableMapFactory;
+  private WritableMap writableMap;
+  private DebugBundleReactNativeModule module;
+
+  @Before
+  public void setUp() {
+    reactContext = mock(ReactApplicationContext.class);
+    applicationContext = mock(Context.class);
+    nativeOperations = mock(DebugBundleReactNativeModule.NativeOperations.class);
+    writableMapFactory = mock(DebugBundleReactNativeModule.WritableMapFactory.class);
+    writableMap = mock(WritableMap.class);
+    when(reactContext.getApplicationContext()).thenReturn(applicationContext);
+    when(nativeOperations.statusName()).thenReturn("ONLINE");
+    when(writableMapFactory.create()).thenReturn(writableMap);
+    module = new DebugBundleReactNativeModule(
+        reactContext,
+        nativeOperations,
+        writableMapFactory);
+  }
+
+  @Test
+  public void initializesWithFullConfigurationAndReturnsNativeState() {
+    when(nativeOperations.lastEventAt()).thenReturn(1_234L);
+    Promise promise = mock(Promise.class);
+    ReadableMap config = readableMap(Map.ofEntries(
+        Map.entry("sdkVersion", "1.2.7"),
+        Map.entry("projectToken", "project-token"),
+        Map.entry("enabled", false),
+        Map.entry("environment", "staging"),
+        Map.entry("service", "checkout-mobile"),
+        Map.entry("endpoint", "https://ingest.example.test"),
+        Map.entry("batchSize", 4),
+        Map.entry("flushInterval", 1_250.0),
+        Map.entry("sampleRate", 0.5),
+        Map.entry("sessionSampleRate", 0.75),
+        Map.entry("requestTimeout", 2_500.0),
+        Map.entry("releaseChannel", "beta"),
+        Map.entry("appVersion", "4.2.0"),
+        Map.entry("buildNumber", "42"),
+        Map.entry("maxEventsPerSession", 55),
+        Map.entry("maxBreadcrumbs", 12),
+        Map.entry("captureScreens", false),
+        Map.entry("captureActions", true),
+        Map.entry("captureNetwork", false),
+        Map.entry("captureLogs", false),
+        Map.entry("logLevel", "debug"),
+        Map.entry("headerAllowlist", List.of("x-request-id", 4)),
+        Map.entry("offlineQueueMaxEvents", 75),
+        Map.entry("offlineQueueMaxBytes", 4_096.0),
+        Map.entry("offlineQueueTtl", 9_000.0),
+        Map.entry("maxProbeLabels", 8),
+        Map.entry("maxProbeEntriesPerLabel", 3),
+        Map.entry("probeFlushOnError", false),
+        Map.entry("redactFields", List.of("password"))));
+
+    module.initialize(config, promise);
+
+    verify(nativeOperations).initialize(eq(applicationContext), any(DebugBundleConfig.class));
+    verify(writableMap).putString("status", "online");
+    verify(writableMap).putDouble("lastEventAt", 1_234.0);
+    verify(writableMap).putBoolean("nativeModuleAvailable", true);
+    verify(writableMap).putNull("degradedReason");
+    verify(promise).resolve(writableMap);
+  }
+
+  @Test
+  public void initializationAndStatusFailOpenWithoutThrowingIntoReactNative() {
+    Promise failedPromise = mock(Promise.class);
+    doThrow(new IllegalStateException("native failure"))
+        .when(nativeOperations)
+        .initialize(any(Context.class), any(DebugBundleConfig.class));
+
+    module.initialize(readableMap(Map.of()), failedPromise);
+
+    verify(writableMap).putString("status", "degraded");
+    verify(writableMap).putNull("lastEventAt");
+    verify(writableMap).putString("degradedReason", "android_initialize_failed");
+    verify(failedPromise).resolve(writableMap);
+
+    reset(writableMap);
+    when(nativeOperations.lastEventAt()).thenReturn(null);
+    Promise statusPromise = mock(Promise.class);
+    module.getStatus(statusPromise);
+    verify(writableMap).putNull("lastEventAt");
+    verify(statusPromise).resolve(writableMap);
+  }
+
+  @Test
+  public void translatesEveryLegacyEventFamilyThroughNativeOperations() {
+    assertLegacyEventCalls(
+        Map.of(
+            "event_type", "frontend_exception",
+            "payload", Map.of("error", "checkout failed")),
+        () -> verify(nativeOperations).captureException(
+            any(RuntimeException.class),
+            any(Map.class)));
+    assertLegacyEventCalls(
+        Map.of(
+            "event_type", "frontend_breadcrumb",
+            "payload", Map.of("breadcrumb_type", "screen_transition")),
+        () -> verify(nativeOperations).captureBreadcrumb(
+            eq("screen_transition"),
+            isNull(),
+            any(Map.class)));
+
+    for (Map.Entry<String, DebugBundleLogLevel> entry : Map.of(
+        "debug", DebugBundleLogLevel.Debug,
+        "info", DebugBundleLogLevel.Info,
+        "error", DebugBundleLogLevel.Error,
+        "critical", DebugBundleLogLevel.Critical,
+        "warning", DebugBundleLogLevel.Warning).entrySet()) {
+      assertLegacyEventCalls(
+          Map.of(
+              "event_type", "log_event",
+              "payload", Map.of("message", "checkout", "level", entry.getKey())),
+          () -> verify(nativeOperations).captureLog(
+              eq("checkout"),
+              eq(entry.getValue()),
+              any(Map.class)));
+    }
+
+    assertLegacyEventCalls(
+        Map.of(
+            "event_type", "request_event",
+            "correlation", Map.of("trace_id", "trace-rn"),
+            "payload", Map.of(
+                "method", "POST",
+                "url", "https://example.test/checkout",
+                "route_template", "/checkout",
+                "response_status", 503,
+                "duration_ms", 12.5)),
+        () -> verify(nativeOperations).captureRequest(
+            any(DebugBundleRequestInfo.class),
+            any(DebugBundleResponseInfo.class),
+            any(Map.class),
+            eq(false)));
+    assertLegacyEventCalls(
+        Map.of("event_type", "custom_event"),
+        () -> verify(nativeOperations).captureMessage(
+            eq("react_native_event:custom_event"),
+            eq(DebugBundleLogLevel.Warning),
+            any(Map.class)));
+  }
+
+  @Test
+  public void canonicalEventsAndProbeOperationsReturnTruthfulResultsAndFailClosed() {
+    ReadableMap event = readableMap(Map.of("event_type", "frontend_exception"));
+    Promise canonicalPromise = mock(Promise.class);
+    when(nativeOperations.captureExternalEvent(any(Map.class))).thenReturn(true);
+    module.enqueueCanonicalEvent(event, canonicalPromise);
+    verify(canonicalPromise).resolve(true);
+
+    when(nativeOperations.isProbeActive("checkout.*")).thenReturn(true);
+    assertTrue(module.isProbeActive("checkout.*"));
+    doThrow(new IllegalStateException("probe failure"))
+        .when(nativeOperations)
+        .isProbeActive("broken");
+    assertFalse(module.isProbeActive("broken"));
+
+    Promise initializePromise = mock(Promise.class);
+    module.initialize(
+        readableMap(Map.of(
+            "sdkVersion", "1.2.7",
+            "service", "checkout-mobile",
+            "environment", "test")),
+        initializePromise);
+    Promise probePromise = mock(Promise.class);
+    when(nativeOperations.captureExternalProbe(
+        anyString(),
+        anyString(),
+        anyString(),
+        anyString(),
+        any(Map.class),
+        anyString())).thenReturn(true);
+    module.captureProbe(
+        "checkout.cart",
+        readableMap(Map.of("count", 2)),
+        "2026-07-28T12:00:00.000Z",
+        probePromise);
+    verify(nativeOperations).captureExternalProbe(
+        "1.2.7",
+        "checkout-mobile",
+        "test",
+        "checkout.cart",
+        Map.of("count", 2),
+        "2026-07-28T12:00:00.000Z");
+    verify(probePromise).resolve(true);
+
+    Promise failedCanonicalPromise = mock(Promise.class);
+    doThrow(new IllegalStateException("capture failure"))
+        .when(nativeOperations)
+        .captureExternalEvent(any(Map.class));
+    module.enqueueCanonicalEvent(event, failedCanonicalPromise);
+    verify(failedCanonicalPromise).resolve(false);
+
+    Promise failedProbePromise = mock(Promise.class);
+    doThrow(new IllegalStateException("probe capture failure"))
+        .when(nativeOperations)
+        .captureExternalProbe(anyString(), anyString(), anyString(), anyString(), any(Map.class), anyString());
+    module.captureProbe(
+        "checkout.cart",
+        readableMap(Map.of()),
+        "2026-07-28T12:00:00.000Z",
+        failedProbePromise);
+    verify(failedProbePromise).resolve(false);
+  }
+
+  @Test
+  public void canonicalEventsNormalizeIntegralReactNativeNumbersRecursively() {
+    ReadableMap event = readableMap(Map.of(
+        "event_type", "request_event",
+        "payload", Map.of(
+            "response_status", 503.0,
+            "duration_ms", 12.5,
+            "probe_data", Map.of(
+                "version", 1.0,
+                "values", List.of(2.0, 2.5)))));
+    Promise promise = mock(Promise.class);
+    when(nativeOperations.captureExternalEvent(any(Map.class))).thenReturn(true);
+
+    module.enqueueCanonicalEvent(event, promise);
+
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Map<String, Object>> captor = ArgumentCaptor.forClass(Map.class);
+    verify(nativeOperations).captureExternalEvent(captor.capture());
+    Map<String, Object> payload = (Map<String, Object>) captor.getValue().get("payload");
+    Map<String, Object> probeData = (Map<String, Object>) payload.get("probe_data");
+    assertEquals(503L, payload.get("response_status"));
+    assertEquals(12.5, payload.get("duration_ms"));
+    assertEquals(1L, probeData.get("version"));
+    assertEquals(List.of(2L, 2.5), probeData.get("values"));
+    verify(promise).resolve(true);
+  }
+
+  @Test
+  public void contextTriggerAndFlushOperationsAlwaysResolve() throws Exception {
+    Promise contextPromise = mock(Promise.class);
+    Dynamic tenant = dynamic(ReadableType.String, "checkout");
+    module.setContext("tenant", tenant, contextPromise);
+    verify(nativeOperations).setContext("tenant", "checkout");
+    verify(tenant).recycle();
+    verify(contextPromise).resolve(isNull());
+
+    Promise contextValuePromise = mock(Promise.class);
+    module.setContextValue(
+        "cart",
+        readableMap(Map.of("value", 2)),
+        contextValuePromise);
+    verify(nativeOperations).setContext("cart", 2);
+    verify(contextValuePromise).resolve(isNull());
+
+    Promise triggerPromise = mock(Promise.class);
+    when(nativeOperations.activateProbeTriggerToken("trigger")).thenReturn(true);
+    module.activateProbeTriggerToken("trigger", triggerPromise);
+    verify(triggerPromise).resolve(true);
+
+    Promise flushPromise = mock(Promise.class);
+    module.flush(flushPromise);
+    verify(nativeOperations).flush();
+    verify(flushPromise).resolve(isNull());
+
+    doThrow(new IllegalStateException("context failure"))
+        .when(nativeOperations)
+        .setContext(eq("broken"), any());
+    Promise failedContext = mock(Promise.class);
+    Dynamic failedValue = dynamic(ReadableType.String, "value");
+    module.setContext("broken", failedValue, failedContext);
+    verify(failedValue).recycle();
+    verify(failedContext).resolve(isNull());
+
+    doThrow(new ReflectiveOperationException("flush failure"))
+        .when(nativeOperations)
+        .flush();
+    Promise failedFlush = mock(Promise.class);
+    module.flush(failedFlush);
+    verify(failedFlush).resolve(isNull());
+
+    doThrow(new IllegalStateException("trigger failure"))
+        .when(nativeOperations)
+        .activateProbeTriggerToken("broken");
+    Promise failedTrigger = mock(Promise.class);
+    module.activateProbeTriggerToken("broken", failedTrigger);
+    verify(failedTrigger).resolve(false);
+  }
+
+  @Test
+  public void legacyDynamicContextPreservesEverySupportedValueShape() {
+    assertDynamicContext("null", dynamic(ReadableType.Null, null), null);
+    assertDynamicContext("boolean", dynamic(ReadableType.Boolean, true), true);
+    assertDynamicContext("number", dynamic(ReadableType.Number, 2.5), 2.5);
+    assertDynamicContext("string", dynamic(ReadableType.String, "checkout"), "checkout");
+    assertDynamicContext(
+        "map",
+        dynamic(ReadableType.Map, readableMap(Map.of("count", 2))),
+        Map.of("count", 2));
+    assertDynamicContext(
+        "array",
+        dynamic(ReadableType.Array, readableArray(List.of("cart", 2))),
+        List.of("cart", 2));
+  }
+
+  @Test
+  public void legacyTranslationFailureIsSwallowedAndModuleNameIsStable() {
+    Promise promise = mock(Promise.class);
+    doThrow(new IllegalStateException("legacy failure"))
+        .when(nativeOperations)
+        .captureMessage(anyString(), any(DebugBundleLogLevel.class), any(Map.class));
+
+    module.enqueueEvent(readableMap(Map.of("event_type", "custom_event")), promise);
+
+    verify(promise).resolve(isNull());
+    verify(promise, never()).reject(anyString(), anyString());
+    org.junit.Assert.assertEquals(DebugBundleReactNativeModule.NAME, module.getName());
+  }
+
+  @Test
+  public void reactPackageRegistersOneModuleAndNoViewManagers() {
+    DebugBundleReactNativePackage reactPackage = new DebugBundleReactNativePackage();
+
+    List<NativeModule> modules = reactPackage.createNativeModules(reactContext);
+    List<ViewManager> viewManagers = reactPackage.createViewManagers(reactContext);
+
+    org.junit.Assert.assertEquals(1, modules.size());
+    org.junit.Assert.assertEquals(DebugBundleReactNativeModule.NAME, modules.get(0).getName());
+    assertTrue(viewManagers.isEmpty());
+  }
+
+  @Test
+  public void newArchitectureInteropCanParseEveryExportedMethod() throws Exception {
+    Class<?> interop = Class.forName(
+        "com.facebook.react.internal.turbomodule.core.TurboModuleInteropUtils");
+    java.lang.reflect.Method parser = interop.getDeclaredMethod(
+        "getMethodDescriptorsFromModule",
+        NativeModule.class);
+    parser.setAccessible(true);
+
+    List<?> descriptors = (List<?>) parser.invoke(null, module);
+
+    assertFalse(descriptors.isEmpty());
+  }
+
+  private void assertLegacyEventCalls(
+      Map<String, Object> event,
+      Runnable verification) {
+    Promise promise = mock(Promise.class);
+    module.enqueueEvent(readableMap(event), promise);
+    verification.run();
+    verify(promise).resolve(isNull());
+  }
+
+  private void assertDynamicContext(String key, Dynamic value, Object expected) {
+    Promise promise = mock(Promise.class);
+    module.setContext(key, value, promise);
+    verify(nativeOperations).setContext(key, expected);
+    verify(value).recycle();
+    verify(promise).resolve(isNull());
+  }
+
+  private static Dynamic dynamic(ReadableType type, Object value) {
+    Dynamic dynamic = mock(Dynamic.class);
+    when(dynamic.getType()).thenReturn(type);
+    when(dynamic.isNull()).thenReturn(type == ReadableType.Null);
+    switch (type) {
+      case Boolean:
+        when(dynamic.asBoolean()).thenReturn((Boolean) value);
+        break;
+      case Number:
+        when(dynamic.asDouble()).thenReturn((Double) value);
+        break;
+      case String:
+        when(dynamic.asString()).thenReturn((String) value);
+        break;
+      case Map:
+        when(dynamic.asMap()).thenReturn((ReadableMap) value);
+        break;
+      case Array:
+        when(dynamic.asArray()).thenReturn((ReadableArray) value);
+        break;
+      default:
+        break;
+    }
+    return dynamic;
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private static ReadableArray readableArray(List<?> values) {
+    ReadableArray array = mock(ReadableArray.class);
+    when(array.toArrayList()).thenReturn((java.util.ArrayList) new java.util.ArrayList<>((List) values));
+    return array;
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private static ReadableMap readableMap(Map<String, ?> values) {
+    Map<String, Object> copy = new HashMap<>((Map) values);
+    ReadableMap readableMap = mock(ReadableMap.class);
+    when(readableMap.hasKey(anyString()))
+        .thenAnswer(invocation -> copy.containsKey(invocation.getArgument(0)));
+    when(readableMap.isNull(anyString()))
+        .thenAnswer(invocation -> copy.get(invocation.getArgument(0)) == null);
+    when(readableMap.getString(anyString()))
+        .thenAnswer(invocation -> (String) copy.get(invocation.getArgument(0)));
+    when(readableMap.getBoolean(anyString()))
+        .thenAnswer(invocation -> (Boolean) copy.get(invocation.getArgument(0)));
+    when(readableMap.getInt(anyString()))
+        .thenAnswer(invocation -> ((Number) copy.get(invocation.getArgument(0))).intValue());
+    when(readableMap.getDouble(anyString()))
+        .thenAnswer(invocation -> ((Number) copy.get(invocation.getArgument(0))).doubleValue());
+    when(readableMap.getMap(anyString()))
+        .thenAnswer(invocation -> {
+          Object value = copy.get(invocation.getArgument(0));
+          if (value instanceof ReadableMap) {
+            return value;
+          }
+          if (value instanceof Map) {
+            return readableMap((Map<String, ?>) value);
+          }
+          return null;
+        });
+    when(readableMap.getArray(anyString()))
+        .thenAnswer(invocation -> {
+          Object value = copy.get(invocation.getArgument(0));
+          if (!(value instanceof List)) {
+            return null;
+          }
+          ReadableArray array = mock(ReadableArray.class);
+          when(array.toArrayList()).thenReturn((java.util.ArrayList) new java.util.ArrayList<>((List) value));
+          return array;
+        });
+    when(readableMap.toHashMap()).thenReturn(new HashMap<>(copy));
+    return readableMap;
+  }
+}

package/app.plugin.js

@@ -49,4 +49,4 @@ function withAndroidDesugaring(contents) {
   return next;
 }
 
-export default createRunOncePlugin(withDebugBundle, "@debugbundle/sdk-react-native", "1.0.0");
+export default createRunOncePlugin(withDebugBundle, "@debugbundle/sdk-react-native", "1.2.0");

package/dist/NativeDebugBundleReactNative.d.ts

@@ -2,10 +2,14 @@ import type { TurboModule } from "react-native";
 import type { UnsafeObject } from "react-native/Libraries/Types/CodegenTypes";
 export interface Spec extends TurboModule {
     initialize(config: UnsafeObject): Promise<UnsafeObject>;
+    enqueueCanonicalEvent?(event: UnsafeObject): Promise<boolean>;
     enqueueEvent(event: UnsafeObject): Promise<void>;
+    captureProbe?(label: string, data: UnsafeObject, occurredAt: string): Promise<boolean>;
+    isProbeActive?(label: string): boolean;
     flush(): Promise<void>;
     getStatus(): Promise<UnsafeObject>;
-    setContext(key: string, value: unknown): Promise<void>;
+    setContext(key: string, value: UnsafeObject): Promise<void>;
+    setContextValue?(key: string, entry: UnsafeObject): Promise<void>;
     activateProbeTriggerToken?(token: string): Promise<boolean>;
 }
 declare const _default: Spec;

package/dist/NativeDebugBundleReactNative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeDebugBundleReactNative.d.ts","sourceRoot":"","sources":["../src/NativeDebugBundleReactNative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAG9E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACnC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,yBAAyB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;;AAED,wBAAgF"}
+{"version":3,"file":"NativeDebugBundleReactNative.d.ts","sourceRoot":"","sources":["../src/NativeDebugBundleReactNative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAG9E,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACxD,qBAAqB,CAAC,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,YAAY,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvF,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACnC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,eAAe,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,yBAAyB,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7D;;AAED,wBAAgF"}

package/dist/before-send.d.ts

@@ -0,0 +1,3 @@
+import type { DebugBundleBeforeSend, DebugBundleEventEnvelope } from "./types.js";
+export declare function applyBeforeSend(event: DebugBundleEventEnvelope, hook: DebugBundleBeforeSend | null): DebugBundleEventEnvelope | null;
+//# sourceMappingURL=before-send.d.ts.map

package/dist/before-send.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before-send.d.ts","sourceRoot":"","sources":["../src/before-send.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AA2ClF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,wBAAwB,EAC/B,IAAI,EAAE,qBAAqB,GAAG,IAAI,GACjC,wBAAwB,GAAG,IAAI,CAajC"}

package/dist/before-send.js

@@ -0,0 +1,136 @@
+const ROOT_KEYS = new Set([
+    "schema_version",
+    "event_id",
+    "event_type",
+    "sdk_name",
+    "sdk_version",
+    "service",
+    "occurred_at",
+    "correlation",
+    "context",
+    "payload"
+]);
+const REQUIRED_PAYLOAD_FIELDS = {
+    frontend_exception: ["name", "message", "stack"],
+    frontend_breadcrumb: ["breadcrumb_type", "data"],
+    log_event: ["level", "message", "attributes"],
+    request_event: ["method", "path", "query", "headers", "response_status", "duration_ms"],
+    error_suppressed: ["fingerprint", "suppressed_count", "window_seconds", "first_seen", "last_seen"],
+    probe_event: ["label", "data", "activation_id", "probe_label_pattern"]
+};
+const ALLOWED_PAYLOAD_FIELDS = {
+    frontend_exception: new Set([
+        "name", "message", "stack", "route", "browser", "breadcrumbs", "device",
+        "browser_event", "rejection_reason", "dom_context", "probe_data"
+    ]),
+    frontend_breadcrumb: new Set(["breadcrumb_type", "route", "data", "device"]),
+    log_event: new Set(["level", "message", "attributes", "device"]),
+    request_event: new Set([
+        "method", "path", "query", "headers", "body", "response_status", "duration_ms",
+        "route_template", "response_headers", "response_body", "device"
+    ]),
+    error_suppressed: new Set([
+        "fingerprint", "suppressed_count", "window_seconds", "first_seen", "last_seen", "device"
+    ]),
+    probe_event: new Set(["label", "data", "activation_id", "probe_label_pattern", "device"])
+};
+const EVENT_TYPES = new Set(Object.keys(REQUIRED_PAYLOAD_FIELDS));
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function applyBeforeSend(event, hook) {
+    if (!hook) {
+        return event;
+    }
+    try {
+        const result = hook(cloneEvent(event));
+        if (result === null) {
+            return null;
+        }
+        return isValidEvent(result) ? result : event;
+    }
+    catch {
+        return event;
+    }
+}
+function cloneEvent(event) {
+    return JSON.parse(JSON.stringify(event));
+}
+function isValidEvent(event) {
+    if (!isRecord(event) || !Object.keys(event).every((key) => ROOT_KEYS.has(key))) {
+        return false;
+    }
+    if (event.schema_version !== "2026-03-01" ||
+        !UUID_PATTERN.test(stringValue(event.event_id)) ||
+        !EVENT_TYPES.has(stringValue(event.event_type)) ||
+        event.sdk_name !== "@debugbundle/sdk-react-native" ||
+        !nonEmptyString(event.sdk_version) ||
+        !isIsoTimestamp(event.occurred_at) ||
+        !isRecord(event.service) ||
+        !nonEmptyString(event.service.name) ||
+        !nonEmptyString(event.service.environment) ||
+        event.service.runtime !== "react-native" ||
+        event.service.framework !== "react-native" ||
+        !isRecord(event.payload)) {
+        return false;
+    }
+    const eventType = event.event_type;
+    return (REQUIRED_PAYLOAD_FIELDS[eventType].every((field) => Object.prototype.hasOwnProperty.call(event.payload, field)) &&
+        Object.keys(event.payload).every((field) => ALLOWED_PAYLOAD_FIELDS[eventType].has(field)) &&
+        hasValidPayloadShape(eventType, event.payload));
+}
+function hasValidPayloadShape(eventType, payload) {
+    switch (eventType) {
+        case "frontend_exception":
+            return (hasNonEmptyStrings(payload, "name", "message", "stack") &&
+                (!("breadcrumbs" in payload) || Array.isArray(payload.breadcrumbs)) &&
+                optionalRecord(payload, "probe_data"));
+        case "frontend_breadcrumb":
+            return hasNonEmptyStrings(payload, "breadcrumb_type") && isRecord(payload.data);
+        case "log_event":
+            return hasNonEmptyStrings(payload, "level", "message") && isRecord(payload.attributes);
+        case "request_event":
+            return (hasNonEmptyStrings(payload, "method", "path") &&
+                isRecord(payload.query) &&
+                isRecord(payload.headers) &&
+                isNonNegativeNumber(payload.response_status) &&
+                isNonNegativeNumber(payload.duration_ms) &&
+                optionalRecord(payload, "response_headers"));
+        case "error_suppressed":
+            return (hasNonEmptyStrings(payload, "fingerprint") &&
+                isNonNegativeInteger(payload.suppressed_count) &&
+                isPositiveInteger(payload.window_seconds) &&
+                isIsoTimestamp(payload.first_seen) &&
+                isIsoTimestamp(payload.last_seen));
+        case "probe_event":
+            return (hasNonEmptyStrings(payload, "label", "probe_label_pattern") &&
+                isRecord(payload.data) &&
+                (payload.activation_id === null ||
+                    nonEmptyString(payload.activation_id) && UUID_PATTERN.test(payload.activation_id)));
+    }
+}
+function hasNonEmptyStrings(payload, ...fields) {
+    return fields.every((field) => nonEmptyString(payload[field]));
+}
+function optionalRecord(payload, field) {
+    return !(field in payload) || isRecord(payload[field]);
+}
+function isNonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isNonNegativeInteger(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function isIsoTimestamp(value) {
+    return nonEmptyString(value) && Number.isFinite(Date.parse(value));
+}

package/dist/client.d.ts

@@ -7,8 +7,6 @@ export declare class DebugBundleReactNativeClient implements DebugBundleClient {
     private breadcrumbs;
     private probeBuffers;
     private jsProbeActivationExpiresAt;
-    private sessionSampledIn;
-    private sessionEventCount;
     constructor(config?: DebugBundleConfig);
     get status(): DebugBundleStatus;
     get lastEventAt(): number | null;
@@ -29,7 +27,6 @@ export declare class DebugBundleReactNativeClient implements DebugBundleClient {
     private mergeContext;
     private snapshotProbeData;
     private hasActiveJsProbeActivation;
-    private shouldCaptureRequestEvent;
 }
 export declare function createDebugBundleClient(config?: DebugBundleConfig): DebugBundleReactNativeClient;
 export declare function resolveConfig(config: DebugBundleConfig): ResolvedDebugBundleConfig;

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EAEjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EAGjB,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAYpB,qBAAa,4BAA6B,YAAW,iBAAiB;IACpE,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,WAAW,CAAkE;IACrF,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,YAAY,CAAqD;IACzE,OAAO,CAAC,0BAA0B,CAAK;IACvC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,iBAAiB,CAAK;gBAElB,MAAM,GAAE,iBAAsB;IAO1C,IAAI,MAAM,IAAI,iBAAiB,CAE9B;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,IAAI,CAE/B;IAED,IAAI,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IA8BrC,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAU/E,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAI3E,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,mBAA+B,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAYlH,cAAc,CACZ,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,OAAO,GAAE,yBAA8B,GACtC,IAAI;IAsBP,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,mBAA+B,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAQtH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAO7C,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,EAAE,OAAO,GAAE,uBAA4B,GAAG,IAAI;IAmB5F,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWhE,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,IAAI;IASxE,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,GAAG,IAAW,EAAE,MAAM,SAAqB,GAAG,IAAI;IAWzG,OAAO,CAAC,OAAO;IAoCf,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,0BAA0B;IAIlC,OAAO,CAAC,yBAAyB;CAGlC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,GAAE,iBAAsB,GAAG,4BAA4B,CAEpG;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,yBAAyB,CAqClF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EAEjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EAIjB,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAYpB,qBAAa,4BAA6B,YAAW,iBAAiB;IACpE,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,WAAW,CAAkE;IACrF,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,YAAY,CAAqD;IACzE,OAAO,CAAC,0BAA0B,CAAK;gBAE3B,MAAM,GAAE,iBAAsB;IAO1C,IAAI,MAAM,IAAI,iBAAiB,CAE9B;IAED,IAAI,WAAW,IAAI,MAAM,GAAG,IAAI,CAE/B;IAED,IAAI,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IA8BrC,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAc/E,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAI3E,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,mBAA+B,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAYlH,cAAc,CACZ,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,OAAO,GAAE,yBAA8B,GACtC,IAAI;IA+BP,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,mBAA+B,EAAE,OAAO,GAAE,yBAA8B,GAAG,IAAI;IAQtH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAS7C,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,EAAE,OAAO,GAAE,uBAA4B,GAAG,IAAI;IA4B5F,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWhE,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,IAAI;IAcxE,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,GAAE,MAAM,GAAG,IAAW,EAAE,MAAM,SAAqB,GAAG,IAAI;IAWzG,OAAO,CAAC,OAAO;IA6Cf,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,0BAA0B;CAInC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,GAAE,iBAAsB,GAAG,4BAA4B,CAEpG;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,iBAAiB,GAAG,yBAAyB,CAsClF"}