@logbrew/react-native 0.1.22 → 0.1.23

package/LogBrewReactNative.podspec

@@ -16,6 +16,7 @@ Pod::Spec.new do |spec|
   }
   spec.default_subspecs = "Core"
   spec.swift_versions = ["5.0"]
+  spec.frameworks = "Security"
   spec.dependency "React-Core"
 
   spec.subspec "Core" do |core|

package/README.md

@@ -588,11 +588,17 @@ export function App({ client }) {
 
 Screen views carry the versioned `screen_view` analytics classification, and explicit product actions carry `interaction`. The SDK uses the app-owned screen name as a bounded surface and does not inspect view hierarchies, selectors, or input values. Caller metadata cannot replace the reserved classification. See the repository [product analytics capture contract](../../docs/product-analytics-contract.md).
 
-The package ships a `react-native` entry that imports `AppState` and `Platform` for Metro, while the default Node entry accepts those dependencies explicitly. That keeps mobile setup explicit instead of pretending a Node process is a native runtime.
+The package ships a `react-native` entry that binds platform state and linked native services for Metro, while the default server entry accepts runtime dependencies explicitly. That keeps mobile setup explicit without treating a server process as a native runtime.
 
 ## Trace Propagation
 
-Use an active trace when one product operation should connect screen views, logs, handled errors, actions, network milestones, explicit spans, and outbound request headers. `createReactNativeTraceContext()` continues a valid W3C `traceparent` with a fresh local span ID and falls back to a local root when the incoming value is missing or malformed:
+Use an active trace when one product operation should connect screen views, logs, handled errors, actions, network milestones, explicit spans, and outbound request headers. `createReactNativeTraceContext()` continues a valid W3C `traceparent` with a fresh local span ID and falls back to a local root when the incoming value is missing or malformed.
+
+The React Native entry creates trace and span IDs with the linked platform's
+cryptographic random source, or Expo Crypto in a managed runtime. It fails
+closed when neither source exists and never falls back to `Math.random` or
+predictable bytes. Callers may still inject `randomValues` when deterministic
+input control is required.
 
 ```js
 import {

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

@@ -12,6 +12,7 @@ import java.io.File;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -22,6 +23,7 @@ import java.util.Set;
 
 final class FatalStoreModuleImpl {
   static final String NAME = "LogBrewFatalStore";
+  private static final SecureRandom SECURE_RANDOM = new SecureRandom();
 
   private static final Set<String> RECORD_KEYS =
       new HashSet<>(
@@ -51,6 +53,20 @@ final class FatalStoreModuleImpl {
                 new AndroidParentDirectorySync());
   }
 
+  String secureRandomHex(double length) {
+    Integer byteCount = integer(length);
+    if (byteCount == null || byteCount < 1 || byteCount > 64) {
+      return "";
+    }
+    byte[] bytes = new byte[byteCount];
+    SECURE_RANDOM.nextBytes(bytes);
+    StringBuilder output = new StringBuilder(byteCount * 2);
+    for (byte value : bytes) {
+      output.append(String.format(java.util.Locale.ROOT, "%02x", value & 0xff));
+    }
+    return output.toString();
+  }
+
   WritableMap loadEventRecords(String queueKey) {
     try {
       EventRecordStore eventStore = eventStore(queueKey);

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

@@ -17,6 +17,11 @@ final class FatalStoreModule extends NativeLogBrewFatalStoreSpec {
     return FatalStoreModuleImpl.NAME;
   }
 
+  @Override
+  public String secureRandomHex(double length) {
+    return implementation.secureRandomHex(length);
+  }
+
   @Override
   public WritableMap writeFatalRecord(ReadableMap record) {
     return implementation.writeFatalRecord(record);

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

@@ -19,6 +19,11 @@ final class FatalStoreModule extends ReactContextBaseJavaModule {
     return FatalStoreModuleImpl.NAME;
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String secureRandomHex(double length) {
+    return implementation.secureRandomHex(length);
+  }
+
   @ReactMethod(isBlockingSynchronousMethod = true)
   public WritableMap writeFatalRecord(ReadableMap record) {
     return implementation.writeFatalRecord(record);

package/index.cjs

@@ -16,8 +16,9 @@ const {
 } = require("./metadata.cjs");
 
 const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.22";
+const DEFAULT_SDK_VERSION = "0.1.23";
 const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
+const NATIVE_RANDOM_HEX = Symbol.for("co.logbrew.react-native.secure-random-hex");
 const MAX_ACTION_NAME_LENGTH = 64;
 const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;
 const SCREEN_ACTION_PREFIX = "screen:";
@@ -913,11 +914,32 @@ function boundedBreadcrumbMessage(value) {
 }
 
 function defaultRandomValues(length) {
-  if (!globalThis.crypto || typeof globalThis.crypto.getRandomValues !== "function") {
-    throw new SdkError("configuration_error", "createReactNativeTraceparent requires crypto.getRandomValues or randomValues");
-  }
   const bytes = new Uint8Array(length);
-  return globalThis.crypto.getRandomValues(bytes);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    return globalThis.crypto.getRandomValues(bytes);
+  }
+  if (typeof globalThis.expo?.modules?.ExpoCrypto?.getRandomValues === "function") {
+    globalThis.expo.modules.ExpoCrypto.getRandomValues(bytes);
+    return bytes;
+  }
+  const nativeRandom = globalThis[NATIVE_RANDOM_HEX];
+  if (typeof nativeRandom !== "function") {
+    throw secureRandomError();
+  }
+  let nativeHex;
+  try {
+    nativeHex = nativeRandom(length);
+  } catch {
+    throw secureRandomError();
+  }
+  if (typeof nativeHex !== "string" || nativeHex.length !== length * 2 || !/^[0-9a-f]+$/iu.test(nativeHex)) {
+    throw secureRandomError();
+  }
+  return Uint8Array.from({ length }, (_, index) => Number.parseInt(nativeHex.slice(index * 2, index * 2 + 2), 16));
+}
+
+function secureRandomError() {
+  return new SdkError("configuration_error", "createReactNativeTraceparent requires secure random values");
 }
 
 function headersWithTraceparent(headers, traceparent) {

package/index.native.js

@@ -1,4 +1,4 @@
-import { AppState, Platform } from "react-native";
+import { AppState, NativeModules, Platform, TurboModuleRegistry } from "react-native";
 import {
   captureAppStateChange,
   captureReactNativeAction,
@@ -34,6 +34,13 @@ export {
 
 export * from "./index.js";
 
+const nativeRuntime = TurboModuleRegistry?.get?.("LogBrewFatalStore")
+  ?? NativeModules?.LogBrewFatalStore;
+if (typeof nativeRuntime?.secureRandomHex === "function") {
+  globalThis[Symbol.for("co.logbrew.react-native.secure-random-hex")] =
+    nativeRuntime.secureRandomHex.bind(nativeRuntime);
+}
+
 export function createLogBrewReactNativeClient(config = {}) {
   const input = config !== null && typeof config === "object" ? config : {};
   const {

package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift

@@ -3,7 +3,7 @@ import Foundation
 @objc(LBRNAppleNativeDiagnostics)
 public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
     private static let shared = LBRNAppleNativeDiagnostics()
-    private static let sdkVersion = "0.1.22"
+    private static let sdkVersion = "0.1.23"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")

package/ios/LBRNFatalStoreModule.mm

@@ -5,7 +5,9 @@
 #import "LBRNPrivateStorage.h"
 
 #import <CommonCrypto/CommonDigest.h>
+#import <Security/SecRandom.h>
 #import <TargetConditionals.h>
+#import <math.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <LogBrewReactNativeSpec/LogBrewReactNativeSpec.h>
@@ -130,6 +132,23 @@ RCT_EXPORT_MODULE(LogBrewFatalStore)
     return self;
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(secureRandomHex:(double)length)
+{
+    if (!isfinite(length) || length < 1 || length > 64 || floor(length) != length) {
+        return @"";
+    }
+    uint8_t bytes[64];
+    NSUInteger byteCount = (NSUInteger)length;
+    if (SecRandomCopyBytes(kSecRandomDefault, byteCount, bytes) != errSecSuccess) {
+        return @"";
+    }
+    NSMutableString *output = [NSMutableString stringWithCapacity:byteCount * 2];
+    for (NSUInteger index = 0; index < byteCount; index += 1) {
+        [output appendFormat:@"%02x", bytes[index]];
+    }
+    return output;
+}
+
 - (nullable LBRNEventRecordStore *)eventStoreForQueueKey:(NSString *)queueKey
 {
     NSString *queueHash = LBRNQueueHash(queueKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/react-native",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "React Native offline delivery, Apple native diagnostics, screen, error, trace, action, and network timeline helpers for LogBrew.",
   "type": "module",
   "main": "./index.cjs",

package/resource-fetch.js

@@ -1,464 +1,6 @@
-import {
-  SdkError
-} from "@logbrew/sdk";
-import {
-  captureReactNativeResourceSpan,
-  createReactNativeTraceContext,
-  createTraceparentFetch,
-  getActiveLogBrewTrace
-} from "./index.js";
-import {
-  createSafeReactNativeMetadata,
-  safeReactNativeMetadataFactoryResult
-} from "./metadata.js";
+import implementation from "./resource-fetch.cjs";
 
-const MAX_GRAPHQL_BODY_CHARS = 16_384;
-const MAX_GRAPHQL_OPERATION_NAME_CHARS = 128;
-const GRAPHQL_OPERATION_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/u;
-const GRAPHQL_OPERATION_RE = /^(query|mutation|subscription)\b(?:\s+([_A-Za-z][_0-9A-Za-z]*))?/u;
-
-export function createReactNativeResourceFetch(client, {
-  appState,
-  fetchImpl,
-  metadata = {},
-  metadataFactory,
-  measureResponseBodySize = false,
-  now = () => new Date().toISOString(),
-  nowMs = () => Date.now(),
-  platform,
-  randomValues,
-  routeTemplate,
-  routeTemplateFactory = defaultRouteTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  traceFlags = "01",
-  tracePropagationTargets = []
-} = {}) {
-  if (routeTemplateFactory !== undefined && typeof routeTemplateFactory !== "function") {
-    throw new SdkError("configuration_error", "routeTemplateFactory must be a function");
-  }
-  if (metadataFactory !== undefined && typeof metadataFactory !== "function") {
-    throw new SdkError("configuration_error", "metadataFactory must be a function");
-  }
-
-  return async function logBrewResourceFetch(input, init) {
-    const startedAtMs = nowMs();
-    const timestamp = now();
-    const activeTrace = resourceTraceContext({ randomValues, trace, traceFlags });
-    const tracedFetch = createTraceparentFetch({
-      fetchImpl,
-      trace: activeTrace,
-      tracePropagationTargets
-    });
-    const method = requestMethod(input, init);
-    const url = requestUrl(input);
-    const safeRouteTemplate = routeTemplate ?? routeTemplateFactory({ input, init, url });
-    try {
-      const response = await tracedFetch(input, init);
-      const responseStartDurationMs = elapsedMs(startedAtMs, nowMs);
-      const statusCode = responseStatusCode(response);
-      const responseSizeBytes = await responseSizeBytesFromResponse(response, { measureResponseBodySize });
-      const durationMs = elapsedMs(startedAtMs, nowMs);
-      captureReactNativeResourceSpan(client, {
-        appState,
-        durationMs,
-        metadata: {
-          ...createSafeReactNativeMetadata(metadata, metadataFactory, {
-            durationMs,
-            init,
-            input,
-            method,
-            response,
-            responseSizeBytes,
-            responseStartDurationMs,
-            routeTemplate: safeRouteTemplate,
-            statusCode,
-            url
-          }),
-          responseStartDurationMs
-        },
-        method,
-        platform,
-        routeTemplate: safeRouteTemplate,
-        screen,
-        sessionId,
-        responseSizeBytes,
-        statusCode,
-        timestamp,
-        trace: activeTrace
-      });
-      return response;
-    } catch (error) {
-      const durationMs = elapsedMs(startedAtMs, nowMs);
-      captureReactNativeResourceSpan(client, {
-        appState,
-        durationMs,
-        metadata: {
-          ...createSafeReactNativeMetadata(metadata, metadataFactory, {
-            durationMs,
-            error,
-            init,
-            input,
-            method,
-            routeTemplate: safeRouteTemplate,
-            status: "error",
-            url
-          }),
-          fetchErrorName: errorName(error),
-          fetchErrorValueType: typeof error
-        },
-        method,
-        platform,
-        routeTemplate: safeRouteTemplate,
-        screen,
-        sessionId,
-        status: "error",
-        timestamp,
-        trace: activeTrace
-      });
-      throw error;
-    }
-  };
-}
-
-export function createReactNativeGraphQLMetadataFactory({
-  endpoint,
-  metadataFactory
-} = {}) {
-  const endpointMatchers = normalizeGraphQLEndpointMatchers(endpoint);
-  if (metadataFactory !== undefined && typeof metadataFactory !== "function") {
-    throw new SdkError("configuration_error", "metadataFactory must be a function");
-  }
-  return function logBrewReactNativeGraphQLMetadata(context) {
-    const safeMetadata = safeReactNativeMetadataFactoryResult(typeof metadataFactory === "function" ? metadataFactory(context) : undefined);
-    if (endpointMatchers.length > 0 && !matchesGraphQLEndpoint(context, endpointMatchers)) {
-      return safeMetadata;
-    }
-    return {
-      ...safeMetadata,
-      ...graphqlMetadataFromContext(context)
-    };
-  };
-}
-
-function normalizeGraphQLEndpointMatchers(endpoint) {
-  if (endpoint === undefined) {
-    return [];
-  }
-  const endpoints = Array.isArray(endpoint) ? endpoint : [endpoint];
-  return endpoints.map((candidate) => {
-    if (typeof candidate === "string" || candidate instanceof String) {
-      const value = normalizeEndpointString(candidate.toString());
-      if (value === "") {
-        throw new SdkError("configuration_error", "GraphQL endpoint strings must not be empty");
-      }
-      return value;
-    }
-    if (candidate instanceof RegExp || typeof candidate === "function") {
-      return candidate;
-    }
-    throw new SdkError("configuration_error", "GraphQL endpoint must be a string, RegExp, function, or array");
-  });
-}
-
-function matchesGraphQLEndpoint(context, endpointMatchers) {
-  const candidates = graphqlEndpointCandidates(context);
-  return endpointMatchers.some((matcher) => {
-    if (typeof matcher === "string") {
-      return candidates.includes(matcher);
-    }
-    if (matcher instanceof RegExp) {
-      return candidates.some((candidate) => endpointRegExpMatches(matcher, candidate));
-    }
-    return matcher(context) === true;
-  });
-}
-
-function endpointRegExpMatches(matcher, candidate) {
-  matcher.lastIndex = 0;
-  const matched = matcher.test(candidate);
-  matcher.lastIndex = 0;
-  return matched;
-}
-
-function graphqlEndpointCandidates(context) {
-  const candidates = new Set();
-  if (typeof context?.routeTemplate === "string" && context.routeTemplate.trim() !== "") {
-    candidates.add(context.routeTemplate);
-  }
-  for (const candidate of endpointCandidatesFromUrl(context?.url)) {
-    candidates.add(candidate);
-  }
-  return Array.from(candidates);
-}
-
-function normalizeEndpointString(endpoint) {
-  const value = endpoint.trim();
-  const candidates = endpointCandidatesFromUrl(value);
-  return candidates[candidates.length - 1] ?? value.split(/[?#]/u, 1)[0];
-}
-
-function endpointCandidatesFromUrl(value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return [];
-  }
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function") {
-    try {
-      const parsedUrl = new URLConstructor(value, "https://logbrew.local");
-      const candidates = [parsedUrl.pathname];
-      if (/^https?:\/\//iu.test(value)) {
-        candidates.push(`${parsedUrl.origin}${parsedUrl.pathname}`);
-      }
-      return candidates;
-    } catch {
-      // Fall back to query/hash stripping below for non-standard request keys.
-    }
-  }
-  return [value.split(/[?#]/u, 1)[0]];
-}
-
-function graphqlMetadataFromContext(context) {
-  const payload = graphqlPayloadFromBody(requestBody(context));
-  if (!payload) {
-    return {};
-  }
-  const operation = graphqlOperationDetails(payload.query);
-  const operationName = safeGraphqlOperationName(payload.operationName) ?? operation.operationName;
-  const metadata = {};
-  if (operationName) {
-    metadata.graphqlOperationName = operationName;
-  }
-  if (operation.operationType) {
-    metadata.graphqlOperationType = operation.operationType;
-  }
-  return metadata;
-}
-
-function requestBody(context) {
-  const body = context?.init?.body ?? context?.input?.body;
-  if (typeof body === "string") {
-    return body;
-  }
-  if (body instanceof String) {
-    return body.toString();
-  }
-  return undefined;
-}
-
-function graphqlPayloadFromBody(body) {
-  if (typeof body !== "string" || body.length > MAX_GRAPHQL_BODY_CHARS) {
-    return undefined;
-  }
-  try {
-    const payload = JSON.parse(body);
-    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function graphqlOperationDetails(query) {
-  if (typeof query !== "string" || query.length > MAX_GRAPHQL_BODY_CHARS) {
-    return {};
-  }
-  const source = query.trimStart();
-  if (source.startsWith("{")) {
-    return { operationType: "query" };
-  }
-  const match = GRAPHQL_OPERATION_RE.exec(stripLeadingGraphQLComments(source));
-  if (!match) {
-    return {};
-  }
-  return {
-    operationName: safeGraphqlOperationName(match[2]),
-    operationType: match[1]
-  };
-}
-
-function stripLeadingGraphQLComments(source) {
-  return source.replace(/^(?:#[^\n\r]*(?:\r?\n|$)\s*)+/u, "").trimStart();
-}
-
-function safeGraphqlOperationName(value) {
-  if (typeof value !== "string") {
-    return undefined;
-  }
-  const name = value.trim();
-  if (
-    name.length === 0 ||
-    name.length > MAX_GRAPHQL_OPERATION_NAME_CHARS ||
-    !GRAPHQL_OPERATION_NAME_RE.test(name)
-  ) {
-    return undefined;
-  }
-  return name;
-}
-
-function requestMethod(input, init) {
-  const method = init?.method ?? input?.method ?? "GET";
-  return String(method).toUpperCase();
-}
-
-function resourceTraceContext({ randomValues, trace, traceFlags }) {
-  if (typeof trace === "string") {
-    return createReactNativeTraceContext({ randomValues, traceFlags, traceparent: trace });
-  }
-  return trace ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext({ randomValues, traceFlags });
-}
-
-function requestUrl(input) {
-  if (typeof input === "string") {
-    return input;
-  }
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function" && input instanceof URLConstructor) {
-    return input.toString();
-  }
-  if (typeof input?.url === "string") {
-    return input.url;
-  }
-  return String(input);
-}
-
-function defaultRouteTemplateFactory({ url }) {
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function") {
-    try {
-      const parsedUrl = new URLConstructor(url, "https://logbrew.local");
-      return parsedUrl.pathname;
-    } catch {
-      // Fall back to query/hash stripping below for non-standard request keys.
-    }
-  }
-  return String(url).split(/[?#]/u, 1)[0];
-}
-
-function elapsedMs(startedAtMs, nowMs) {
-  const durationMs = nowMs() - startedAtMs;
-  return Number.isFinite(durationMs) ? Math.max(0, durationMs) : undefined;
-}
-
-function responseStatusCode(response) {
-  return typeof response?.status === "number" && Number.isFinite(response.status) ? response.status : undefined;
-}
-
-async function responseSizeBytesFromResponse(response, { measureResponseBodySize = false } = {}) {
-  const contentLength = responseContentLengthBytes(response);
-  if (contentLength !== undefined) {
-    return contentLength;
-  }
-  return measureResponseBodySize ? clonedResponseBodySizeBytes(response) : undefined;
-}
-
-function responseContentLengthBytes(response) {
-  const header = responseHeader(response, "Content-Length");
-  const value = Number.parseInt(String(header ?? ""), 10);
-  return Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-
-function responseHeader(response, name) {
-  if (typeof response?.headers?.get !== "function") {
-    return undefined;
-  }
-  try {
-    return response.headers.get(name) ?? response.headers.get(name.toLowerCase()) ?? undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function clonedResponseBodySizeBytes(response) {
-  if (typeof response?.clone !== "function") {
-    return undefined;
-  }
-  let clonedResponse;
-  try {
-    clonedResponse = response.clone();
-  } catch {
-    return undefined;
-  }
-  return responseBodySizeBytes(clonedResponse);
-}
-
-async function responseBodySizeBytes(response) {
-  const arrayBufferSize = await responseArrayBufferSizeBytes(response);
-  if (arrayBufferSize !== undefined) {
-    return arrayBufferSize;
-  }
-  const blobSize = await responseBlobSizeBytes(response);
-  if (blobSize !== undefined) {
-    return blobSize;
-  }
-  return responseTextSizeBytes(response);
-}
-
-async function responseArrayBufferSizeBytes(response) {
-  if (typeof response?.arrayBuffer !== "function") {
-    return undefined;
-  }
-  try {
-    return binaryByteLength(await response.arrayBuffer());
-  } catch {
-    return undefined;
-  }
-}
-
-async function responseBlobSizeBytes(response) {
-  if (typeof response?.blob !== "function") {
-    return undefined;
-  }
-  try {
-    const blob = await response.blob();
-    return typeof blob?.size === "number" && Number.isFinite(blob.size) && blob.size >= 0 ? blob.size : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function responseTextSizeBytes(response) {
-  if (typeof response?.text !== "function") {
-    return undefined;
-  }
-  try {
-    const text = await response.text();
-    return typeof text === "string" || text instanceof String ? utf8ByteLength(text.toString()) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function binaryByteLength(value) {
-  if (typeof value?.byteLength === "number" && Number.isFinite(value.byteLength) && value.byteLength >= 0) {
-    return value.byteLength;
-  }
-  return undefined;
-}
-
-function utf8ByteLength(value) {
-  let bytes = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code <= 0x7f) {
-      bytes += 1;
-    } else if (code <= 0x7ff) {
-      bytes += 2;
-    } else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
-      const next = value.charCodeAt(index + 1);
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        bytes += 4;
-        index += 1;
-      } else {
-        bytes += 3;
-      }
-    } else {
-      bytes += 3;
-    }
-  }
-  return bytes;
-}
-
-function errorName(error) {
-  return typeof error?.name === "string" && error.name.trim() !== "" ? error.name : "Error";
-}
+export const {
+  createReactNativeGraphQLMetadataFactory,
+  createReactNativeResourceFetch
+} = implementation;

package/src/NativeLogBrewFatalStore.ts

@@ -2,6 +2,7 @@ import type { CodegenTypes, TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
 
 export interface Spec extends TurboModule {
+  secureRandomHex(length: number): string;
   writeFatalRecord(record: CodegenTypes.UnsafeObject): CodegenTypes.UnsafeObject;
   readFatalRecord(): CodegenTypes.UnsafeObject;
   acknowledgeFatalRecord(recordId: string): CodegenTypes.UnsafeObject;