@logbrew/react-native 0.1.9 → 0.1.11

package/android/src/main/java/co/logbrew/reactnative/FatalStoreModuleImpl.java

@@ -9,10 +9,15 @@ import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 final class FatalStoreModuleImpl {
@@ -32,9 +37,12 @@ final class FatalStoreModuleImpl {
       new HashSet<>(Arrays.asList("filename", "line", "column"));
 
   private final FatalRecordStore store;
+  private final File eventStoreParent;
+  private final Map<String, EventRecordStore> eventStores = new HashMap<>();
 
   FatalStoreModuleImpl(ReactApplicationContext context) {
     File root = context.getNoBackupFilesDir();
+    eventStoreParent = root;
     store =
         root == null
             ? null
@@ -43,6 +51,66 @@ final class FatalStoreModuleImpl {
                 new AndroidParentDirectorySync());
   }
 
+  WritableMap loadEventRecords(String queueKey) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      return eventStore == null ? status("storage_error") : eventResultMap(eventStore.load());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap appendEventRecord(String queueKey, String serializedEvent, double eventBytes) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      Integer byteCount = integer(eventBytes);
+      return eventStore == null || byteCount == null
+          ? status("storage_error")
+          : eventResultMap(eventStore.append(serializedEvent, byteCount));
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      Integer recordCount = integer(count);
+      return eventStore == null || recordCount == null
+          ? status("storage_error")
+          : eventResultMap(eventStore.acknowledge(recordCount));
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  WritableMap purgeEventRecords(String queueKey) {
+    try {
+      EventRecordStore eventStore = eventStore(queueKey);
+      return eventStore == null ? status("storage_error") : eventResultMap(eventStore.purge());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    }
+  }
+
+  synchronized WritableMap closeEventStore(String queueKey) {
+    String queueHash = queueHash(queueKey);
+    if (queueHash == null) {
+      return status("storage_error");
+    }
+    EventRecordStore eventStore = eventStores.get(queueHash);
+    if (eventStore == null) {
+      return status("closed");
+    }
+    try {
+      return eventResultMap(eventStore.close());
+    } catch (RuntimeException error) {
+      return status("storage_error");
+    } finally {
+      eventStores.remove(queueHash);
+    }
+  }
+
   WritableMap writeFatalRecord(ReadableMap input) {
     if (store == null) {
       return status("storage_error");
@@ -227,4 +295,65 @@ final class FatalStoreModuleImpl {
     output.putString("status", value);
     return output;
   }
+
+  private synchronized EventRecordStore eventStore(String queueKey) {
+    String queueHash = queueHash(queueKey);
+    if (eventStoreParent == null || queueHash == null) {
+      return null;
+    }
+    EventRecordStore existing = eventStores.get(queueHash);
+    if (existing != null) {
+      return existing;
+    }
+    EventRecordStore created =
+        new EventRecordStore(
+            new File(eventStoreParent, "logbrew-events-v1-" + queueHash),
+            new AndroidParentDirectorySync());
+    eventStores.put(queueHash, created);
+    return created;
+  }
+
+  private static String queueHash(String queueKey) {
+    if (queueKey == null || queueKey.trim().isEmpty()) {
+      return null;
+    }
+    byte[] keyBytes = queueKey.getBytes(StandardCharsets.UTF_8);
+    if (keyBytes.length == 0 || keyBytes.length > 4096) {
+      return null;
+    }
+    try {
+      byte[] digest = MessageDigest.getInstance("SHA-256").digest(keyBytes);
+      StringBuilder value = new StringBuilder(digest.length * 2);
+      for (byte item : digest) {
+        value.append(String.format(java.util.Locale.ROOT, "%02x", item & 0xff));
+      }
+      return value.toString();
+    } catch (NoSuchAlgorithmException impossible) {
+      return null;
+    }
+  }
+
+  private static Integer integer(double value) {
+    return Double.isFinite(value)
+            && value >= 0
+            && value <= Integer.MAX_VALUE
+            && value == Math.rint(value)
+        ? (int) value
+        : null;
+  }
+
+  private static WritableMap eventResultMap(EventRecordStore.Result result) {
+    WritableMap output = status(result.status);
+    if ("loaded".equals(result.status)) {
+      WritableArray records = Arguments.createArray();
+      for (EventRecordStore.Record record : result.records) {
+        WritableMap value = Arguments.createMap();
+        value.putString("serializedEvent", record.serializedEvent);
+        value.putInt("eventBytes", record.eventBytes);
+        records.pushMap(value);
+      }
+      output.putArray("records", records);
+    }
+    return output;
+  }
 }

package/android/src/newarch/java/co/logbrew/reactnative/FatalStoreModule.java

@@ -36,4 +36,30 @@ final class FatalStoreModule extends NativeLogBrewFatalStoreSpec {
   public WritableMap discardFatalRecord() {
     return implementation.discardFatalRecord();
   }
+
+  @Override
+  public WritableMap loadEventRecords(String queueKey) {
+    return implementation.loadEventRecords(queueKey);
+  }
+
+  @Override
+  public WritableMap appendEventRecord(
+      String queueKey, String serializedEvent, double eventBytes) {
+    return implementation.appendEventRecord(queueKey, serializedEvent, eventBytes);
+  }
+
+  @Override
+  public WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    return implementation.acknowledgeEventRecords(queueKey, count);
+  }
+
+  @Override
+  public WritableMap purgeEventRecords(String queueKey) {
+    return implementation.purgeEventRecords(queueKey);
+  }
+
+  @Override
+  public WritableMap closeEventStore(String queueKey) {
+    return implementation.closeEventStore(queueKey);
+  }
 }

package/android/src/oldarch/java/co/logbrew/reactnative/FatalStoreModule.java

@@ -38,4 +38,30 @@ final class FatalStoreModule extends ReactContextBaseJavaModule {
   public WritableMap discardFatalRecord() {
     return implementation.discardFatalRecord();
   }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap loadEventRecords(String queueKey) {
+    return implementation.loadEventRecords(queueKey);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap appendEventRecord(
+      String queueKey, String serializedEvent, double eventBytes) {
+    return implementation.appendEventRecord(queueKey, serializedEvent, eventBytes);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap acknowledgeEventRecords(String queueKey, double count) {
+    return implementation.acknowledgeEventRecords(queueKey, count);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap purgeEventRecords(String queueKey) {
+    return implementation.purgeEventRecords(queueKey);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap closeEventStore(String queueKey) {
+    return implementation.closeEventStore(queueKey);
+  }
 }

package/global-errors.cjs

@@ -3,7 +3,8 @@
 const { createReactNativeErrorEvent } = require("./index.cjs");
 const { createFatalController } = require("./fatal-replay.cjs");
 const {
-  createLogBrewReactNativePromiseRejectionHandlers
+  createLogBrewReactNativePromiseRejectionHandlers,
+  installLogBrewReactNativePromiseRejectionTracker
 } = require("./promise-rejections.cjs");
 
 const AUTOMATIC_ERROR_MESSAGE = "React Native global JavaScript report";
@@ -412,7 +413,8 @@ function isObjectLike(value) {
 
 const defaultExport = {
   createLogBrewReactNativePromiseRejectionHandlers,
-  installLogBrewReactNativeGlobalErrorHandler
+  installLogBrewReactNativeGlobalErrorHandler,
+  installLogBrewReactNativePromiseRejectionTracker
 };
 
 module.exports = { ...defaultExport, default: defaultExport };

package/global-errors.d.cts

@@ -14,6 +14,9 @@ export type ReactNativePromiseRejectionDiagnosticCode =
   | "promise_rejection_handler_unavailable"
   | "promise_rejection_id_unavailable"
   | "promise_rejection_recursive_capture_suppressed"
+  | "promise_rejection_tracker_installation_failed"
+  | "promise_rejection_tracker_ownership_required"
+  | "promise_rejection_tracker_unavailable"
   | "promise_rejection_tracking_evicted";
 
 export type ReactNativePromiseRejectionDiagnostic = Readonly<{
@@ -96,6 +99,54 @@ export type LogBrewReactNativePromiseRejectionHandlers = Readonly<{
   onUnhandled(runtimeRejectionId: unknown, rejection?: unknown): void;
 }>;
 
+export type ReactNativePromiseRejectionTrackerLike = {
+  enable(options: Readonly<{
+    allRejections: true;
+    onHandled(runtimeRejectionId: unknown): void;
+    onUnhandled(runtimeRejectionId: unknown, rejection?: unknown): void;
+  }>): void;
+};
+
+export type InstallLogBrewReactNativePromiseRejectionTrackerOptions = {
+  client: Pick<LogBrewClient, "issue">;
+  /**
+   * Confirms that LogBrew may claim the runtime's single Promise rejection
+   * tracker slot. Do not install another tracker owner at the same time.
+   */
+  takeOwnership: true;
+  /**
+   * Optional tracker seam. The React Native conditional export discovers the
+   * active Hermes tracker when this is omitted.
+   */
+  tracker?: ReactNativePromiseRejectionTrackerLike;
+  maxTrackedRejections?: number;
+  onDiagnostic?: (diagnostic: ReactNativePromiseRejectionDiagnostic) => void;
+};
+
+export type ReactNativePromiseRejectionTrackerHealth = Readonly<{
+  active: boolean;
+  available: boolean;
+  engine: "custom" | "hermes" | "unavailable";
+  lastOutcome:
+    | "deactivated"
+    | "handler_unavailable"
+    | "installation_failed"
+    | "installed"
+    | "ownership_required"
+    | "tracker_unavailable";
+  restoration: "deactivate_only";
+}>;
+
+export type LogBrewReactNativePromiseRejectionTrackerInstallation = Readonly<{
+  /**
+   * Stops LogBrew capture through the installed callbacks. Hermes does not
+   * expose a previous-owner restoration API, so this cannot restore one.
+   */
+  deactivate(): boolean;
+  health(): ReactNativePromiseRejectionTrackerHealth;
+  rejectionHealth(): ReactNativePromiseRejectionHealth;
+}>;
+
 export type ReactNativeFatalRecord = Readonly<{
   corruptRecords: number;
   droppedRecords: number;
@@ -175,6 +226,17 @@ export declare function createLogBrewReactNativePromiseRejectionHandlers(
   options: CreateLogBrewReactNativePromiseRejectionHandlersOptions
 ): LogBrewReactNativePromiseRejectionHandlers;
 
+/**
+ * Install privacy-safe automatic Promise rejection capture.
+ *
+ * Installation is opt-in because React Native runtimes expose one tracker slot.
+ * The React Native conditional export discovers Hermes without replacing the
+ * global Promise. Other runtimes can inject a compatible tracker explicitly.
+ */
+export declare function installLogBrewReactNativePromiseRejectionTracker(
+  options: InstallLogBrewReactNativePromiseRejectionTrackerOptions
+): LogBrewReactNativePromiseRejectionTrackerInstallation;
+
 /**
  * Install reversible automatic capture for React Native global JavaScript errors.
  *
@@ -190,6 +252,7 @@ export declare function installLogBrewReactNativeGlobalErrorHandler(
 declare const logBrewReactNativeGlobalErrors: {
   createLogBrewReactNativePromiseRejectionHandlers: typeof createLogBrewReactNativePromiseRejectionHandlers;
   installLogBrewReactNativeGlobalErrorHandler: typeof installLogBrewReactNativeGlobalErrorHandler;
+  installLogBrewReactNativePromiseRejectionTracker: typeof installLogBrewReactNativePromiseRejectionTracker;
 };
 
 export default logBrewReactNativeGlobalErrors;

package/global-errors.d.ts

@@ -14,6 +14,9 @@ export type ReactNativePromiseRejectionDiagnosticCode =
   | "promise_rejection_handler_unavailable"
   | "promise_rejection_id_unavailable"
   | "promise_rejection_recursive_capture_suppressed"
+  | "promise_rejection_tracker_installation_failed"
+  | "promise_rejection_tracker_ownership_required"
+  | "promise_rejection_tracker_unavailable"
   | "promise_rejection_tracking_evicted";
 
 export type ReactNativePromiseRejectionDiagnostic = Readonly<{
@@ -96,6 +99,54 @@ export type LogBrewReactNativePromiseRejectionHandlers = Readonly<{
   onUnhandled(runtimeRejectionId: unknown, rejection?: unknown): void;
 }>;
 
+export type ReactNativePromiseRejectionTrackerLike = {
+  enable(options: Readonly<{
+    allRejections: true;
+    onHandled(runtimeRejectionId: unknown): void;
+    onUnhandled(runtimeRejectionId: unknown, rejection?: unknown): void;
+  }>): void;
+};
+
+export type InstallLogBrewReactNativePromiseRejectionTrackerOptions = {
+  client: Pick<LogBrewClient, "issue">;
+  /**
+   * Confirms that LogBrew may claim the runtime's single Promise rejection
+   * tracker slot. Do not install another tracker owner at the same time.
+   */
+  takeOwnership: true;
+  /**
+   * Optional tracker seam. The React Native conditional export discovers the
+   * active Hermes tracker when this is omitted.
+   */
+  tracker?: ReactNativePromiseRejectionTrackerLike;
+  maxTrackedRejections?: number;
+  onDiagnostic?: (diagnostic: ReactNativePromiseRejectionDiagnostic) => void;
+};
+
+export type ReactNativePromiseRejectionTrackerHealth = Readonly<{
+  active: boolean;
+  available: boolean;
+  engine: "custom" | "hermes" | "unavailable";
+  lastOutcome:
+    | "deactivated"
+    | "handler_unavailable"
+    | "installation_failed"
+    | "installed"
+    | "ownership_required"
+    | "tracker_unavailable";
+  restoration: "deactivate_only";
+}>;
+
+export type LogBrewReactNativePromiseRejectionTrackerInstallation = Readonly<{
+  /**
+   * Stops LogBrew capture through the installed callbacks. Hermes does not
+   * expose a previous-owner restoration API, so this cannot restore one.
+   */
+  deactivate(): boolean;
+  health(): ReactNativePromiseRejectionTrackerHealth;
+  rejectionHealth(): ReactNativePromiseRejectionHealth;
+}>;
+
 export type ReactNativeFatalRecord = Readonly<{
   corruptRecords: number;
   droppedRecords: number;
@@ -175,6 +226,17 @@ export declare function createLogBrewReactNativePromiseRejectionHandlers(
   options: CreateLogBrewReactNativePromiseRejectionHandlersOptions
 ): LogBrewReactNativePromiseRejectionHandlers;
 
+/**
+ * Install privacy-safe automatic Promise rejection capture.
+ *
+ * Installation is opt-in because React Native runtimes expose one tracker slot.
+ * The React Native conditional export discovers Hermes without replacing the
+ * global Promise. Other runtimes can inject a compatible tracker explicitly.
+ */
+export declare function installLogBrewReactNativePromiseRejectionTracker(
+  options: InstallLogBrewReactNativePromiseRejectionTrackerOptions
+): LogBrewReactNativePromiseRejectionTrackerInstallation;
+
 /**
  * Install reversible automatic capture for React Native global JavaScript errors.
  *
@@ -190,6 +252,7 @@ export declare function installLogBrewReactNativeGlobalErrorHandler(
 declare const logBrewReactNativeGlobalErrors: {
   createLogBrewReactNativePromiseRejectionHandlers: typeof createLogBrewReactNativePromiseRejectionHandlers;
   installLogBrewReactNativeGlobalErrorHandler: typeof installLogBrewReactNativeGlobalErrorHandler;
+  installLogBrewReactNativePromiseRejectionTracker: typeof installLogBrewReactNativePromiseRejectionTracker;
 };
 
 export default logBrewReactNativeGlobalErrors;

package/global-errors.js

@@ -2,7 +2,8 @@ import implementation from "./global-errors.cjs";
 
 export const {
   createLogBrewReactNativePromiseRejectionHandlers,
-  installLogBrewReactNativeGlobalErrorHandler
+  installLogBrewReactNativeGlobalErrorHandler,
+  installLogBrewReactNativePromiseRejectionTracker
 } = implementation;
 
 export default implementation;

package/global-errors.native.js

@@ -2,13 +2,16 @@ import { NativeModules, TurboModuleRegistry } from "react-native";
 
 import {
   createLogBrewReactNativePromiseRejectionHandlers,
-  installLogBrewReactNativeGlobalErrorHandler as installPlatformNeutralHandler
+  installLogBrewReactNativeGlobalErrorHandler as installPlatformNeutralHandler,
+  installLogBrewReactNativePromiseRejectionTracker as installPlatformNeutralTracker
 } from "./global-errors.js";
 
 export {
   createLogBrewReactNativePromiseRejectionHandlers
 };
 
+const hermesTrackerAdapters = new WeakMap();
+
 function defaultFatalStore() {
   try {
     return TurboModuleRegistry?.get?.("LogBrewFatalStore")
@@ -18,6 +21,40 @@ function defaultFatalStore() {
   }
 }
 
+function defaultPromiseRejectionTracker() {
+  let hermes;
+  let enable;
+  let hasPromise;
+  try {
+    hermes = globalThis?.HermesInternal;
+    if (hermes === null
+      || (typeof hermes !== "object" && typeof hermes !== "function")) {
+      return undefined;
+    }
+    enable = hermes.enablePromiseRejectionTracker;
+    hasPromise = hermes.hasPromise;
+    if (typeof enable !== "function"
+      || typeof hasPromise !== "function"
+      || hasPromise.call(hermes) !== true) {
+      return undefined;
+    }
+  } catch {
+    return undefined;
+  }
+
+  const existing = hermesTrackerAdapters.get(hermes);
+  if (existing) {
+    return existing;
+  }
+  const adapter = Object.freeze({
+    enable(options) {
+      return enable.call(hermes, options);
+    }
+  });
+  hermesTrackerAdapters.set(hermes, adapter);
+  return adapter;
+}
+
 export function installLogBrewReactNativeGlobalErrorHandler(options = {}) {
   let forwarded;
   let hasInjectedStore = false;
@@ -37,9 +74,33 @@ export function installLogBrewReactNativeGlobalErrorHandler(options = {}) {
   });
 }
 
+export function installLogBrewReactNativePromiseRejectionTracker(options = {}) {
+  let forwarded;
+  let hasInjectedTracker = false;
+  try {
+    const input = options !== null
+      && (typeof options === "object" || typeof options === "function")
+      ? options
+      : {};
+    hasInjectedTracker = Object.prototype.hasOwnProperty.call(input, "tracker");
+    forwarded = { ...input };
+  } catch {
+    forwarded = {};
+  }
+  const tracker = hasInjectedTracker
+    ? forwarded.tracker
+    : defaultPromiseRejectionTracker();
+  return installPlatformNeutralTracker({
+    ...forwarded,
+    tracker,
+    trackerKind: hasInjectedTracker ? "custom" : tracker ? "hermes" : undefined
+  });
+}
+
 const logBrewReactNativeGlobalErrors = {
   createLogBrewReactNativePromiseRejectionHandlers,
-  installLogBrewReactNativeGlobalErrorHandler
+  installLogBrewReactNativeGlobalErrorHandler,
+  installLogBrewReactNativePromiseRejectionTracker
 };
 
 export default logBrewReactNativeGlobalErrors;

package/index.cjs

@@ -29,6 +29,7 @@ function createLogBrewReactNativeClient({
   clientKey,
   deliveryIntervalMs,
   deliveryQueueThreshold,
+  eventStore,
   maxBatchBytes,
   maxBatchEvents,
   maxQueueBytes,
@@ -48,6 +49,7 @@ function createLogBrewReactNativeClient({
     automaticDelivery,
     deliveryIntervalMs,
     deliveryQueueThreshold,
+    eventStore,
     maxBatchBytes,
     maxBatchEvents,
     maxQueueBytes,

package/index.d.cts

@@ -4,6 +4,7 @@ import type {
   DeliveryHealthSnapshot,
   DroppedEvent,
   EnvironmentAttributes,
+  EventStore,
   IssueAttributes,
   LogAttributes,
   LogBrewClient,
@@ -37,6 +38,8 @@ export type CreateLogBrewReactNativeClientConfig = {
   clientKey?: string;
   deliveryIntervalMs?: number;
   deliveryQueueThreshold?: number;
+  /** Advanced synchronous persistence seam. React Native apps normally use the native entry's persistentQueue mode. */
+  eventStore?: EventStore;
   maxBatchBytes?: number;
   maxBatchEvents?: number;
   maxQueueBytes?: number;

package/index.d.ts

@@ -4,6 +4,7 @@ import type {
   DeliveryHealthSnapshot,
   DroppedEvent,
   EnvironmentAttributes,
+  EventStore,
   IssueAttributes,
   LogAttributes,
   LogBrewClient,
@@ -37,6 +38,8 @@ export type CreateLogBrewReactNativeClientConfig = {
   clientKey?: string;
   deliveryIntervalMs?: number;
   deliveryQueueThreshold?: number;
+  /** Advanced synchronous persistence seam. React Native apps normally use the native entry's persistentQueue mode. */
+  eventStore?: EventStore;
   maxBatchBytes?: number;
   maxBatchEvents?: number;
   maxQueueBytes?: number;

package/index.js

@@ -29,6 +29,7 @@ export function createLogBrewReactNativeClient({
   clientKey,
   deliveryIntervalMs,
   deliveryQueueThreshold,
+  eventStore,
   maxBatchBytes,
   maxBatchEvents,
   maxQueueBytes,
@@ -48,6 +49,7 @@ export function createLogBrewReactNativeClient({
     automaticDelivery,
     deliveryIntervalMs,
     deliveryQueueThreshold,
+    eventStore,
     maxBatchBytes,
     maxBatchEvents,
     maxQueueBytes,

package/index.native.d.ts

@@ -1,2 +1,47 @@
-export * from "./index";
-export { installLogBrewReactNativeGlobalErrorHandler } from "./global-errors";
+import type { EventStore, LogBrewClient } from "@logbrew/sdk";
+import type { CreateLogBrewReactNativeClientConfig } from "./index.js";
+
+export * from "./index.js";
+export {
+  installLogBrewReactNativeGlobalErrorHandler,
+  installLogBrewReactNativePromiseRejectionTracker
+} from "./global-errors";
+
+export type ReactNativePersistentQueueMode = "auto" | "required" | "disabled";
+
+export type CreateNativeLogBrewReactNativeClientConfig =
+  Omit<CreateLogBrewReactNativeClientConfig, "eventStore"> & ({
+    /**
+     * `auto` uses the linked app-private native queue when available and otherwise uses memory.
+     * `required` fails client creation when the native queue is unavailable. `disabled` uses memory.
+     */
+    persistentQueue?: ReactNativePersistentQueueMode;
+    eventStore?: undefined;
+  } | {
+    /** Advanced app-owned synchronous persistence adapter. Mutually exclusive with persistentQueue. */
+    eventStore: EventStore;
+    persistentQueue?: never;
+  });
+
+export declare function createLogBrewReactNativeClient(
+  config: CreateNativeLogBrewReactNativeClientConfig
+): LogBrewClient;
+
+export declare function createDefaultLogBrewReactNativeClient(
+  config: CreateNativeLogBrewReactNativeClientConfig
+): LogBrewClient;
+
+export declare function purgeLogBrewReactNativePersistentQueue(
+  config: { apiKey?: string; clientKey?: string }
+): void;
+
+declare const defaultExport: Omit<
+  typeof import("./index.js").default,
+  "createLogBrewReactNativeClient" | "createDefaultLogBrewReactNativeClient"
+> & {
+  createLogBrewReactNativeClient: typeof createLogBrewReactNativeClient;
+  createDefaultLogBrewReactNativeClient: typeof createDefaultLogBrewReactNativeClient;
+  purgeLogBrewReactNativePersistentQueue: typeof purgeLogBrewReactNativePersistentQueue;
+};
+
+export default defaultExport;