@logbrew/react-native 0.1.18 → 0.1.20

package/index.js

@@ -1,1207 +1,36 @@
-import React from "react";
-import {
-  createIssueAttributesFromError,
-  createTraceparent,
-  LogBrewClient,
-  parseTraceparent,
-  PRODUCT_ANALYTICS_SCHEMA_VERSION,
-  SdkError,
-  TransportError
-} from "@logbrew/sdk";
-import {
-  runtimeReactNativeDebugIdMap,
-  sanitizeReactNativeIssueExceptionChain,
-  sanitizeReactNativeIssueMetadata,
-  sanitizeReactNativeIssueStackFrames
-} from "./metadata.js";
-
-const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.18";
-const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
-const MAX_ACTION_NAME_LENGTH = 64;
-const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;
-const SCREEN_ACTION_PREFIX = "screen:";
-const BACKGROUND_APP_STATES = new Set(["background", "inactive"]);
-const LogBrewNativeContext = React.createContext(null);
-const activeTraceScopes = [];
-let nextTraceScopeId = 0;
-
-export function createLogBrewReactNativeClient({
-  automaticDelivery,
-  apiKey,
-  clientKey,
-  context,
-  deliveryIntervalMs,
-  deliveryQueueThreshold,
-  eventStore,
-  maxBatchBytes,
-  maxBatchEvents,
-  maxQueueBytes,
-  maxQueueSize,
-  onEventDropped,
-  sdkName = DEFAULT_SDK_NAME,
-  sdkVersion = DEFAULT_SDK_VERSION,
-  maxRetries = 2,
-  transport
-}) {
-  const authKey = clientKey ?? apiKey;
-  if (!authKey) {
-    throw new SdkError("configuration_error", "createLogBrewReactNativeClient requires clientKey or apiKey");
-  }
-  return LogBrewClient.create({
-    apiKey: authKey,
-    automaticDelivery,
-    context,
-    deliveryIntervalMs,
-    deliveryQueueThreshold,
-    eventStore,
-    maxBatchBytes,
-    maxBatchEvents,
-    maxQueueBytes,
-    maxQueueSize,
-    maxRetries,
-    onEventDropped,
-    sdkName,
-    sdkVersion,
-    transport
-  });
-}
-
-export function createReactNativeFetchTransport({
-  endpoint = DEFAULT_ENDPOINT,
-  fetchImpl = defaultFetch(),
-  headers = {}
-} = {}) {
-  validateDeliveryEndpoint(endpoint);
-  if (typeof fetchImpl !== "function") {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport requires fetch");
-  }
-  if (!headers || Array.isArray(headers) || typeof headers !== "object") {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport headers must be an object");
-  }
-
-  return Object.freeze({
-    async send(apiKey, body) {
-      try {
-        const response = await fetchImpl(endpoint, {
-          body,
-          headers: {
-            ...headers,
-            authorization: `Bearer ${apiKey}`,
-            "content-type": "application/json"
-          },
-          method: "POST"
-        });
-        const retryAfterMs = retryAfterMsFromHeaders(response?.headers);
-        return retryAfterMs === undefined
-          ? { statusCode: response?.status, attempts: 1 }
-          : { statusCode: response?.status, attempts: 1, retryAfterMs };
-      } catch {
-        throw TransportError.network("LogBrew React Native delivery failed");
-      }
-    }
-  });
-}
-
-export function createReactNativeTraceparent({ randomValues = defaultRandomValues, spanId, traceFlags = "01", traceId } = {}) {
-  return createTraceparent({
-    spanId: spanId ?? randomHex(8, randomValues),
-    traceFlags,
-    traceId: traceId ?? randomHex(16, randomValues)
-  });
-}
-
-export function createReactNativeTraceContext({
-  parentSpanId, randomValues = defaultRandomValues, spanId, traceFlags = "01", traceId, traceparent
-} = {}) {
-  if (traceparent !== undefined && traceparent !== null && String(traceparent).trim() !== "") {
-    try {
-      const parsed = parseTraceparent(traceparent);
-      const localSpanId = spanId ?? randomHex(8, randomValues);
-      createTraceparent({ traceId: parsed.traceId, spanId: localSpanId, traceFlags: parsed.traceFlags });
-      return freezeTraceContext({
-        parentSpanId: parsed.parentSpanId,
-        sampled: parsed.sampled,
-        spanId: localSpanId,
-        traceFlags: parsed.traceFlags,
-        traceId: parsed.traceId
-      });
-    } catch {
-      // Bad upstream propagation should not break mobile app flows.
-    }
-  }
-
-  const localTraceId = traceId ?? randomHex(16, randomValues);
-  const localSpanId = spanId ?? randomHex(8, randomValues);
-  createTraceparent({ traceId: localTraceId, spanId: localSpanId, traceFlags });
-  if (parentSpanId !== undefined) {
-    createTraceparent({ traceId: localTraceId, spanId: parentSpanId, traceFlags });
-  }
-  return freezeTraceContext({
-    parentSpanId,
-    sampled: sampledFromTraceFlags(traceFlags),
-    spanId: localSpanId,
-    traceFlags,
-    traceId: localTraceId
-  });
-}
-
-export function getActiveLogBrewTrace() {
-  return activeTraceScopes.length === 0 ? undefined : activeTraceScopes[activeTraceScopes.length - 1].trace;
-}
-
-export function withLogBrewTrace(trace, callback) {
-  if (typeof callback !== "function") {
-    throw new SdkError("configuration_error", "withLogBrewTrace requires a callback");
-  }
-  const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
-  const scope = {
-    id: ++nextTraceScopeId,
-    trace: context
-  };
-  activeTraceScopes.push(scope);
-  try {
-    return callback(context);
-  } finally {
-    removeActiveTraceScope(scope.id);
-  }
-}
-
-export function bindLogBrewTrace(trace, callback) {
-  if (typeof callback !== "function") {
-    throw new SdkError("configuration_error", "bindLogBrewTrace requires a callback");
-  }
-  const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
-  return function logBrewTracedCallback(...args) {
-    return withLogBrewTrace(context, () => callback(...args));
-  };
-}
-
-export function getReactNativeTraceMetadata(trace = getActiveLogBrewTrace()) {
-  const context = resolveTraceContext(trace);
-  if (!context) {
-    return {};
-  }
-  return compactMetadata({
-    parentSpanId: context.parentSpanId,
-    spanId: context.spanId,
-    traceFlags: context.traceFlags,
-    traceId: context.traceId,
-    traceSampled: context.sampled
-  });
-}
-
-export function createReactNativeSpanAttributes({
-  durationMs,
-  metadata = {},
-  name,
-  spanId,
-  status = "ok",
-  trace = getActiveLogBrewTrace()
-} = {}) {
-  const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
-  return {
-    name,
-    traceId: context.traceId,
-    spanId: spanId ?? context.spanId,
-    status,
-    durationMs,
-    metadata: compactMetadata({
-      ...metadata,
-      ...getReactNativeTraceMetadata(context)
-    })
-  };
-}
-
-export function createReactNativeTraceHeaders(trace = getActiveLogBrewTrace()) {
-  const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
-  return {
-    traceparent: createTraceparent({
-      traceFlags: context.traceFlags,
-      traceId: context.traceId,
-      spanId: context.spanId
-    })
-  };
-}
-
-export function createTraceparentFetch({
-  fetchImpl = defaultFetch(),
-  randomValues = defaultRandomValues,
-  trace,
-  traceFlags = "01",
-  traceparent,
-  traceparentFactory,
-  tracePropagationTargets = []
-} = {}) {
-  if (typeof fetchImpl !== "function") {
-    throw new SdkError("configuration_error", "createTraceparentFetch requires fetch");
-  }
-  if (!Array.isArray(tracePropagationTargets)) {
-    throw new SdkError("configuration_error", "tracePropagationTargets must be an array");
-  }
-  if (traceparentFactory !== undefined && typeof traceparentFactory !== "function") {
-    throw new SdkError("configuration_error", "traceparentFactory must be a function");
-  }
-
-  return async function tracedFetch(input, init) {
-    const url = requestUrl(input);
-    if (!shouldPropagateTraceparent(url, tracePropagationTargets)) {
-      return init === undefined ? fetchImpl(input) : fetchImpl(input, init);
-    }
-
-    const requestInit = init ?? {};
-    const nextTraceparent = traceparentForRequest({ init, input, randomValues, trace, traceFlags, traceparent, traceparentFactory, url });
-    const nextInit = {
-      ...requestInit,
-      headers: headersWithTraceparent(requestHeaders(input, requestInit), nextTraceparent)
-    };
-    return fetchImpl(input, nextInit);
-  };
-}
-
-export function shouldPropagateTraceparent(url, tracePropagationTargets = []) {
-  if (!Array.isArray(tracePropagationTargets)) {
-    throw new SdkError("configuration_error", "tracePropagationTargets must be an array");
-  }
-  return tracePropagationTargets.some((target) => {
-    if (typeof target === "string") {
-      return shouldPropagateToStringTarget(url, target);
-    }
-    if (target instanceof RegExp) {
-      target.lastIndex = 0;
-      const matched = target.test(url);
-      target.lastIndex = 0;
-      return matched;
-    }
-    if (typeof target === "function") {
-      return target(url) === true;
-    }
-    throw new SdkError("configuration_error", "tracePropagationTargets entries must be strings, RegExp values, or functions");
-  });
-}
-
-export function getReactNativeContext({ platform, appState, metadata = {} } = {}) {
-  return {
-    platform: platform?.OS ?? "unknown",
-    platformVersion: normalizeMetadataValue(platform?.Version),
-    appState: normalizeMetadataValue(appState?.currentState),
-    isPad: normalizeMetadataValue(platform?.isPad),
-    isTesting: normalizeMetadataValue(platform?.constants?.isTesting),
-    ...metadata
-  };
-}
-
-export function captureScreenView(client, screenName, {
-  id = `evt_screen_${slugify(screenName)}`,
-  timestamp = new Date().toISOString(),
-  status = "success",
-  platform,
-  appState,
-  trace,
-  metadata = {}
-} = {}) {
-  requireClient(client);
-  requireNonEmpty("screen name", screenName);
-  client.action(id, timestamp, {
-    name: screenActionName(screenName),
-    status,
-    metadata: {
-      ...getReactNativeContext({ platform, appState }),
-      screen: screenName,
-      ...metadata,
-      ...getReactNativeTraceMetadata(trace ?? getActiveLogBrewTrace()),
-      ...productAnalyticsMetadata("screen_view", screenName)
-    }
-  });
-  recordIssueBreadcrumb(client, {
-    timestamp,
-    attributes: { name: screenActionName(screenName), status }
-  }, "navigation", "navigation");
-}
-
-export function captureAppStateChange(client, state, {
-  id = `evt_app_state_${slugify(state)}`,
-  timestamp = new Date().toISOString(),
-  platform,
-  appState,
-  trace,
-  metadata = {}
-} = {}) {
-  requireClient(client);
-  requireNonEmpty("app state", state);
-  client.action(id, timestamp, {
-    name: "app_state_change",
-    status: "success",
-    metadata: {
-      ...getReactNativeContext({ platform, appState }),
-      appState: state,
-      ...metadata,
-      ...getReactNativeTraceMetadata(trace ?? getActiveLogBrewTrace())
-    }
-  });
-  recordIssueBreadcrumb(client, {
-    timestamp,
-    attributes: { name: "app_state_change", status: "success" }
-  }, "app.state", "state");
-}
-
-export function createReactNativeActionEvent({
-  id,
-  idFactory = defaultActionEventId,
-  metadata = {},
-  name,
-  now = () => new Date().toISOString(),
-  platform,
-  appState,
-  screen,
-  sessionId,
-  status = "success",
-  timestamp,
-  trace,
-  traceId
-} = {}) {
-  return {
-    id: id ?? idFactory({ name, screen }),
-    timestamp: timestamp ?? now(),
-    attributes: {
-      name,
-      status,
-      metadata: compactMetadata({
-        ...getReactNativeContext({ platform, appState }),
-        source: "react-native.action",
-        screen,
-        sessionId,
-        traceId,
-        ...metadata,
-        ...getReactNativeTraceMetadata(trace ?? getActiveLogBrewTrace()),
-        ...productAnalyticsMetadata("interaction", screen)
-      })
-    }
-  };
-}
-
-export function captureReactNativeAction(client, input = {}) {
-  requireClient(client);
-  const event = createReactNativeActionEvent(input);
-  client.action(event.id, event.timestamp, event.attributes);
-  recordIssueBreadcrumb(client, event, "ui.action", "user");
-  return event;
-}
-
-export function createReactNativeNetworkEvent({
-  durationMs,
-  id,
-  idFactory = defaultNetworkEventId,
-  metadata = {},
-  method,
-  name,
-  now = () => new Date().toISOString(),
-  platform,
-  appState,
-  routeTemplate,
-  screen,
-  sessionId,
-  status,
-  statusCode,
-  timestamp,
-  trace,
-  traceId
-} = {}) {
-  const safeRouteTemplate = stripQueryAndHash(routeTemplate);
-  const safeMethod = method === undefined ? undefined : String(method).toUpperCase();
-  const actionName = name ?? [safeMethod, safeRouteTemplate].filter(Boolean).join(" ");
-  return {
-    id: id ?? idFactory({ method: safeMethod, routeTemplate: safeRouteTemplate, screen }),
-    timestamp: timestamp ?? now(),
-    attributes: {
-      name: actionName,
-      status: status ?? statusFromStatusCode(statusCode),
-      metadata: compactMetadata({
-        ...getReactNativeContext({ platform, appState }),
-        source: "react-native.network",
-        durationMs,
-        method: safeMethod,
-        routeTemplate: safeRouteTemplate,
-        screen,
-        sessionId,
-        statusCode,
-        traceId,
-        ...metadata,
-        ...getReactNativeTraceMetadata(trace ?? getActiveLogBrewTrace())
-      })
-    }
-  };
-}
-
-export function captureReactNativeNetwork(client, input = {}) {
-  requireClient(client);
-  const event = createReactNativeNetworkEvent(input);
-  client.action(event.id, event.timestamp, event.attributes);
-  recordIssueBreadcrumb(client, event, "http", "http");
-  return event;
-}
-
-export function createReactNativeNavigationSpanEvent({
-  actionType, durationMs, id, idFactory = defaultNavigationSpanEventId, includeRouteKey = false, metadata = {},
-  name, now = () => new Date().toISOString(), platform, appState, previousRouteKey, previousRouteName,
-  routeKey, routeName, routePath, screen, status = "ok", timestamp, trace
-} = {}) {
-  const safeRoutePath = stripQueryAndHash(routePath);
-  const spanName = name ?? `navigation:${routeName ?? safeRoutePath ?? screen ?? "route"}`;
-  const context = resolveTraceContext(trace) ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext();
-  return {
-    id: id ?? idFactory({ routeName, routePath: safeRoutePath, screen }),
-    timestamp: timestamp ?? now(),
-    attributes: createReactNativeSpanAttributes({
-      name: spanName,
-      status,
-      durationMs,
-      trace: context,
-      metadata: {
-        ...getReactNativeContext({ platform, appState }),
-        source: "react-native.navigation",
-        actionType,
-        previousRouteName,
-        routeName,
-        routePath: safeRoutePath,
-        screen: screen ?? routeName,
-        ...(includeRouteKey ? { previousRouteKey, routeKey } : {}),
-        ...metadata
-      }
-    })
-  };
-}
-
-export function captureReactNativeNavigationSpan(client, input = {}) {
-  requireClient(client);
-  const event = createReactNativeNavigationSpanEvent(input);
-  client.span(event.id, event.timestamp, event.attributes);
-  recordIssueBreadcrumb(client, event, "navigation", "navigation");
-  return event;
-}
-
-export function createReactNativeResourceSpanEvent({
-  durationMs, id, idFactory = defaultResourceSpanEventId, kind = "fetch", metadata = {}, method, name,
-  now = () => new Date().toISOString(), platform, appState, responseSizeBytes, routeTemplate, screen,
-  sessionId, status, statusCode, timestamp, trace
-} = {}) {
-  const safeRouteTemplate = stripQueryAndHash(routeTemplate);
-  const safeMethod = method === undefined ? undefined : String(method).toUpperCase();
-  const defaultName = [safeMethod, safeRouteTemplate].filter(Boolean).join(" ");
-  const spanName = name ?? (defaultName || "mobile.resource");
-  const context = resolveTraceContext(trace) ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext();
-  return {
-    id: id ?? idFactory({ method: safeMethod, routeTemplate: safeRouteTemplate, screen }),
-    timestamp: timestamp ?? now(),
-    attributes: createReactNativeSpanAttributes({
-      name: spanName,
-      status: status ?? spanStatusFromStatusCode(statusCode),
-      durationMs,
-      trace: context,
-      metadata: {
-        ...getReactNativeContext({ platform, appState }),
-        source: "react-native.resource",
-        durationMs,
-        method: safeMethod,
-        resourceKind: kind,
-        responseSizeBytes,
-        routeTemplate: safeRouteTemplate,
-        screen,
-        sessionId,
-        statusCode,
-        ...metadata
-      }
-    })
-  };
-}
-
-export function captureReactNativeResourceSpan(client, input = {}) {
-  requireClient(client);
-  const event = createReactNativeResourceSpanEvent(input);
-  client.span(event.id, event.timestamp, event.attributes);
-  return event;
-}
-
-export function createReactNavigationSpanListener(client, navigationContainer, {
-  captureInitialRoute = false, includeRouteKey = false, metadata = {}, now = () => new Date().toISOString(),
-  nowMs = () => Date.now(), onError, platform, appState, trace
-} = {}) {
-  requireClient(client);
-  const container = resolveNavigationContainer(navigationContainer);
-  if (!container || typeof container.addListener !== "function" || typeof container.getCurrentRoute !== "function") {
-    throw new SdkError("configuration_error", "createReactNavigationSpanListener requires a React Navigation container ref with addListener and getCurrentRoute");
-  }
-
-  let previousRoute = captureInitialRoute ? {} : routeSnapshot(container.getCurrentRoute());
-  let pendingNavigation;
-  const removers = [];
-  const captureCurrentRoute = () => {
-    try {
-      const route = routeSnapshot(container.getCurrentRoute());
-      if (!route.name && !route.path) {
-        return;
-      }
-      const startedAtMs = pendingNavigation?.startedAtMs;
-      const durationMs = startedAtMs === undefined ? undefined : Math.max(0, nowMs() - startedAtMs);
-      captureReactNativeNavigationSpan(client, {
-        actionType: pendingNavigation?.actionType, durationMs, includeRouteKey, metadata, now, platform, appState,
-        previousRouteKey: previousRoute.key, previousRouteName: previousRoute.name, routeKey: route.key,
-        routeName: route.name, routePath: route.path, timestamp: pendingNavigation?.timestamp, trace
-      });
-      previousRoute = route;
-      pendingNavigation = undefined;
-    } catch (error) {
-      if (typeof onError === "function") {
-        onError(error);
-      } else {
-        throw error;
-      }
-    }
-  };
-
-  const actionSubscription = safeNavigationListener(container, "__unsafe_action__", (event) => {
-    pendingNavigation = {
-      actionType: navigationActionType(event),
-      startedAtMs: nowMs(),
-      timestamp: now()
-    };
-  });
-  if (actionSubscription) {
-    removers.push(actionSubscription);
-  }
-  removers.push(addNavigationListener(container, "state", captureCurrentRoute));
-
-  if (captureInitialRoute) {
-    captureCurrentRoute();
-  }
-
-  return () => {
-    for (const remove of removers.splice(0).reverse()) {
-      remove();
-    }
-  };
-}
-
-export function createReactNativeErrorEvent(error, {
-  debugIdMap,
-  evidence,
-  environment,
-  fingerprint,
-  handled = true,
-  id,
-  idFactory = defaultErrorEventId,
-  includeStack = false,
-  level = "error",
-  mechanism = "react-native.error",
-  metadata = {},
-  now = () => new Date().toISOString(),
-  platform,
-  appState,
-  release,
-  runtime,
-  screen,
-  service,
-  timestamp,
-  trace
-} = {}) {
-  const details = errorDetails(error);
-  const traceContext = resolveTraceContext(trace ?? getActiveLogBrewTrace());
-  const attributes = createIssueAttributesFromError(error?.reason ?? error?.error ?? error, {
-    debugIdMap: debugIdMap === undefined ? runtimeReactNativeDebugIdMap() : debugIdMap,
-    evidence,
-    environment,
-    fingerprint,
-    handled,
-    includeErrorStack: includeStack,
-    level,
-    mechanism,
-    metadata: {
-      ...getReactNativeContext({ platform, appState }),
-      errorValueType: details.valueType,
-      screen,
-      ...metadata
-    },
-    release,
-    runtime,
-    service,
-    source: "react-native.error",
-    trace: traceContext
-  });
-  const stackFrames = sanitizeReactNativeIssueStackFrames(attributes.stackFrames);
-  const exceptionChain = sanitizeReactNativeIssueExceptionChain(attributes.exceptionChain);
-  return {
-    id: id ?? idFactory({ error, message: details.message, screen }),
-    timestamp: timestamp ?? now(),
-    attributes: {
-      ...attributes,
-      ...(exceptionChain ? { exceptionChain } : {}),
-      ...(stackFrames ? { stackFrames } : {}),
-      title: `React Native error: ${details.message}`,
-      message: details.message,
-      metadata: sanitizeReactNativeIssueMetadata(attributes.metadata, compactMetadata)
-    }
-  };
-}
-
-export function captureReactNativeError(client, error, options = {}) {
-  requireClient(client);
-  const event = createReactNativeErrorEvent(error, options);
-  client.issue(event.id, event.timestamp, event.attributes);
-  return event;
-}
-
-export function createAppStateListener(client, appState, options = {}) {
-  requireClient(client);
-  if (!appState || typeof appState.addEventListener !== "function") {
-    throw new SdkError("configuration_error", "createAppStateListener requires AppState.addEventListener");
-  }
-  const {
-    flushOnBackground = false,
-    onFlushError,
-    ...captureOptions
-  } = options;
-  if (typeof flushOnBackground !== "boolean") {
-    throw new SdkError("configuration_error", "createAppStateListener flushOnBackground must be a boolean");
-  }
-  if (onFlushError !== undefined && typeof onFlushError !== "function") {
-    throw new SdkError("configuration_error", "createAppStateListener onFlushError must be a function");
-  }
-
-  const subscription = appState.addEventListener("change", (nextState) => {
-    captureAppStateChange(client, nextState, {
-      ...captureOptions,
-      appState
-    });
-    if (flushOnBackground && BACKGROUND_APP_STATES.has(nextState)) {
-      void client.flush().catch((error) => {
-        if (typeof onFlushError === "function") {
-          try {
-            onFlushError(error);
-          } catch {
-            // Delivery diagnostics must not interrupt the app-state callback.
-          }
-        }
-      });
-    }
-  });
-
-  return subscriptionRemover(subscription);
-}
-
-export function LogBrewNativeProvider({ client, platform, appState, trace, children }) {
-  requireClient(client);
-  const value = React.useMemo(() => ({
-    client,
-    platform,
-    appState,
-    trace: resolveTraceContext(trace)
-  }), [appState, client, platform, trace]);
-  return React.createElement(LogBrewNativeContext.Provider, { value }, children);
-}
-
-export function useLogBrewNative() {
-  const value = React.useContext(LogBrewNativeContext);
-  if (!value?.client) {
-    throw new SdkError("configuration_error", "useLogBrewNative must be used inside LogBrewNativeProvider");
-  }
-  return value;
-}
-
-export function useLogBrewNativeActions() {
-  const { client, platform, appState, trace } = useLogBrewNative();
-  const scoped = (options = {}) => ({ platform, appState, trace, ...options });
-  return {
-    release: client.release.bind(client),
-    environment: client.environment.bind(client),
-    issue: (id, timestamp, attributes) => client.issue(id, timestamp, attributesWithTrace(attributes, trace)),
-    log: (id, timestamp, attributes) => client.log(id, timestamp, attributesWithTrace(attributes, trace)),
-    span: client.span.bind(client),
-    action: (id, timestamp, attributes) => client.action(id, timestamp, attributesWithTrace(attributes, trace)),
-    flush: client.flush.bind(client),
-    shutdown: client.shutdown.bind(client),
-    deliveryHealth: client.deliveryHealth.bind(client),
-    droppedEvents: client.droppedEvents.bind(client),
-    pendingBytes: client.pendingBytes.bind(client),
-    previewJson: client.previewJson.bind(client),
-    pendingEvents: client.pendingEvents.bind(client),
-    trace,
-    captureScreenView: (screenName, options = {}) => captureScreenView(client, screenName, scoped(options)),
-    captureAppStateChange: (state, options = {}) => captureAppStateChange(client, state, scoped(options)),
-    captureReactNativeAction: (input = {}) => captureReactNativeAction(client, scoped(input)),
-    captureReactNativeNetwork: (input = {}) => captureReactNativeNetwork(client, scoped(input)),
-    captureReactNativeNavigationSpan: (input = {}) => captureReactNativeNavigationSpan(client, scoped(input)),
-    captureReactNativeResourceSpan: (input = {}) => captureReactNativeResourceSpan(client, scoped(input)),
-    captureReactNativeError: (error, options = {}) => captureReactNativeError(client, error, scoped(options))
-  };
-}
-
-function requireClient(client) {
-  if (!client) {
-    throw new SdkError("configuration_error", "LogBrew React Native helpers require a client");
-  }
-}
-
-function requireNonEmpty(label, value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new SdkError("validation_error", `${label} must be non-empty`);
-  }
-}
-
-function normalizeMetadataValue(value) {
-  if (value === undefined) {
-    return null;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-    return value;
-  }
-  return String(value);
-}
-
-function compactMetadata(metadata) {
-  const compacted = {};
-  for (const [key, value] of Object.entries(metadata)) {
-    if (value === undefined) {
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-      compacted[key] = value;
-    }
-  }
-  return compacted;
-}
-
-function attributesWithTrace(attributes, trace) {
-  const context = resolveTraceContext(trace) ?? getActiveLogBrewTrace();
-  if (!context) {
-    return attributes;
-  }
-  return {
-    ...attributes,
-    metadata: compactMetadata({
-      ...(attributes?.metadata ?? {}),
-      ...getReactNativeTraceMetadata(context)
-    })
-  };
-}
-
-function errorDetails(error) {
-  const candidate = error?.reason ?? error?.error ?? error;
-  return {
-    message: errorMessage(candidate),
-    valueType: candidate === null ? "null" : typeof candidate
-  };
-}
-
-function errorMessage(error) {
-  if (error instanceof Error && typeof error.message === "string" && error.message.trim() !== "") {
-    return error.message;
-  }
-  if (typeof error?.message === "string" && error.message.trim() !== "") {
-    return error.message;
-  }
-  if (typeof error === "string" && error.trim() !== "") {
-    return error;
-  }
-  return String(error ?? "unknown error");
-}
-
-function validateDeliveryEndpoint(endpoint) {
-  if (typeof endpoint !== "string" || endpoint.trim() === "") {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport requires a non-empty endpoint");
-  }
-  let parsed;
-  try {
-    parsed = new URL(endpoint);
-  } catch {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport endpoint must be an absolute URL");
-  }
-  if (parsed.protocol !== "https:") {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport endpoint must use HTTPS");
-  }
-  if (endpoint !== `${parsed.origin}${parsed.pathname}`) {
-    throw new SdkError("configuration_error", "createReactNativeFetchTransport endpoint must be a plain HTTPS path");
-  }
-}
-
-function retryAfterMsFromHeaders(headers) {
-  if (!headers || typeof headers.get !== "function") {
-    return undefined;
-  }
-  return retryAfterMsFromHeader(headers.get("retry-after"));
-}
-
-function retryAfterMsFromHeader(value, now = Date.now()) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return undefined;
-  }
-  const trimmed = value.trim();
-  if (/^\d+$/u.test(trimmed)) {
-    const milliseconds = Number(trimmed) * 1000;
-    return Number.isSafeInteger(milliseconds) ? milliseconds : undefined;
-  }
-  const timestamp = Date.parse(trimmed);
-  return Number.isFinite(timestamp) ? Math.max(0, timestamp - now) : undefined;
-}
-
-function defaultErrorEventId({ message, screen }) {
-  return `evt_native_error_${slugify(`${screen ?? "app"}_${message}`)}`;
-}
-
-function defaultActionEventId({ name, screen }) {
-  return `evt_native_action_${slugify(`${screen ?? "app"}_${name ?? "event"}`)}`;
-}
-
-function defaultNetworkEventId({ method, routeTemplate, screen }) {
-  return `evt_native_network_${slugify([screen, method, routeTemplate].filter(Boolean).join("_") || "request")}`;
-}
-
-function defaultNavigationSpanEventId({ routeName, routePath, screen }) {
-  return `evt_native_navigation_${slugify([screen, routeName, routePath].filter(Boolean).join("_") || "route")}`;
-}
-
-function defaultResourceSpanEventId({ method, routeTemplate, screen }) {
-  return `evt_native_resource_${slugify([screen, method, routeTemplate].filter(Boolean).join("_") || "request")}`;
-}
-
-function defaultFetch() {
-  return typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined;
-}
-
-function recordIssueBreadcrumb(client, event, category, type) {
-  if (typeof client?.addBreadcrumb !== "function") {
-    return;
-  }
-  const status = typeof event?.attributes?.status === "string"
-    ? event.attributes.status
-    : undefined;
-  const message = boundedBreadcrumbMessage(event?.attributes?.name);
-  client.addBreadcrumb({
-    category,
-    type,
-    level: status === "failure" || status === "error" ? "error" : "info",
-    ...(message === undefined ? {} : { message }),
-    ...(status === undefined ? {} : { data: { status } })
-  }, event.timestamp);
-}
-
-function boundedBreadcrumbMessage(value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return undefined;
-  }
-  const characters = Array.from(value);
-  if (
-    characters.length > 512
-    || characters.some((character) => {
-      const code = character.codePointAt(0);
-      return code !== undefined && (code <= 31 || (code >= 127 && code <= 159));
-    })
-  ) {
-    return undefined;
-  }
-  return 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);
-}
-
-function headersWithTraceparent(headers, traceparent) {
-  const nextHeaders = {};
-  for (const [key, value] of headerEntries(headers)) {
-    if (String(key).toLowerCase() !== "traceparent") {
-      nextHeaders[key] = value;
-    }
-  }
-  nextHeaders.traceparent = traceparent;
-  return nextHeaders;
-}
-
-function headerEntries(headers) {
-  if (headers === undefined || headers === null) {
-    return [];
-  }
-  const HeadersConstructor = globalThis.Headers;
-  if (typeof HeadersConstructor === "function" && headers instanceof HeadersConstructor) {
-    const entries = [];
-    headers.forEach((value, key) => {
-      entries.push([key, value]);
-    });
-    return entries;
-  }
-  if (Array.isArray(headers)) {
-    return headers;
-  }
-  if (typeof headers !== "string" && typeof headers[Symbol.iterator] === "function") {
-    return Array.from(headers);
-  }
-  if (typeof headers === "object") {
-    return Object.entries(headers);
-  }
-  return [];
-}
-
-function randomHex(length, randomValues) {
-  if (typeof randomValues !== "function") {
-    throw new SdkError("configuration_error", "randomValues must be a function");
-  }
-  const bytes = Array.from(randomValues(length));
-  if (bytes.length !== length || bytes.some((value) => !Number.isInteger(value) || value < 0 || value > 255)) {
-    throw new SdkError("configuration_error", "randomValues must return byte values for the requested length");
-  }
-  return bytes.map((value) => value.toString(16).padStart(2, "0")).join("");
-}
-
-function resolveTraceContext(trace) {
-  if (trace === undefined || trace === null) {
-    return undefined;
-  }
-  if (typeof trace === "string") {
-    return createReactNativeTraceContext({ traceparent: trace });
-  }
-  if (typeof trace === "object") {
-    const {
-      parentSpanId,
-      sampled,
-      spanId,
-      traceFlags = "01",
-      traceId
-    } = trace;
-    if (typeof traceId !== "string" || typeof spanId !== "string") {
-      throw new SdkError("validation_error", "trace context requires traceId and spanId");
-    }
-    createTraceparent({ traceId, spanId, traceFlags });
-    if (parentSpanId !== undefined) {
-      createTraceparent({ traceId, spanId: parentSpanId, traceFlags });
-    }
-    return freezeTraceContext({
-      parentSpanId,
-      sampled: sampled ?? sampledFromTraceFlags(traceFlags),
-      spanId,
-      traceFlags,
-      traceId
-    });
-  }
-  throw new SdkError("validation_error", "trace must be a trace context or traceparent string");
-}
-
-function freezeTraceContext({ parentSpanId, sampled, spanId, traceFlags, traceId }) {
-  const normalized = {
-    traceId: String(traceId).toLowerCase(),
-    spanId: String(spanId).toLowerCase(),
-    parentSpanId: parentSpanId === undefined ? undefined : String(parentSpanId).toLowerCase(),
-    traceFlags: String(traceFlags).toLowerCase(),
-    sampled: Boolean(sampled)
-  };
-  return Object.freeze(normalized);
-}
-
-function sampledFromTraceFlags(traceFlags) {
-  return (Number.parseInt(traceFlags, 16) & 1) === 1;
-}
-
-function removeActiveTraceScope(scopeId) {
-  const index = activeTraceScopes.findIndex((scope) => scope.id === scopeId);
-  if (index >= 0) {
-    activeTraceScopes.splice(index, 1);
-  }
-}
-
-function shouldPropagateToStringTarget(url, target) {
-  const targetText = target.trim();
-  if (targetText === "") {
-    return false;
-  }
-  if (targetText.startsWith("/")) {
-    return url.startsWith(targetText);
-  }
-
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function") {
-    try {
-      const targetUrl = new URLConstructor(targetText);
-      if (!hasUrlScheme(url)) {
-        return false;
-      }
-      const requestUrl = new URLConstructor(url, targetUrl.origin);
-      if (requestUrl.origin !== targetUrl.origin) {
-        return false;
-      }
-      const targetPath = targetUrl.pathname || "/";
-      return requestUrl.pathname === targetPath || requestUrl.pathname.startsWith(pathPrefix(targetPath));
-    } catch {
-      return url.startsWith(targetText);
-    }
-  }
-
-  return url.startsWith(targetText);
-}
-
-function pathPrefix(pathname) {
-  return pathname.endsWith("/") ? pathname : `${pathname}/`;
-}
-
-function hasUrlScheme(url) {
-  return /^[a-z][a-z0-9+.-]*:/iu.test(url);
-}
-
-function requestHeaders(input, init) {
-  if (init && init.headers !== undefined) {
-    return init.headers;
-  }
-  return input?.headers;
-}
-
-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 slugify(value) {
-  return String(value)
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "") || "event";
-}
-
-function screenActionName(screenName) {
-  const directName = `${SCREEN_ACTION_PREFIX}${screenName}`;
-  if (
-    directName.length <= MAX_ACTION_NAME_LENGTH
-    && /^[a-z0-9_.:-]+$/i.test(directName)
-  ) {
-    return directName;
-  }
-
-  const maxScreenSegmentLength = MAX_ACTION_NAME_LENGTH - SCREEN_ACTION_PREFIX.length;
-  const screenSegment = slugify(screenName)
-    .slice(0, maxScreenSegmentLength)
-    .replace(/_+$/g, "") || "event";
-  return `${SCREEN_ACTION_PREFIX}${screenSegment}`;
-}
-
-function productAnalyticsMetadata(kind, surface) {
-  return {
-    analyticsSchemaVersion: PRODUCT_ANALYTICS_SCHEMA_VERSION,
-    analyticsKind: kind,
-    analyticsSurface: boundedProductAnalyticsSurface(surface)
-  };
-}
-
-function boundedProductAnalyticsSurface(surface) {
-  if (typeof surface !== "string") {
-    return undefined;
-  }
-  const normalized = surface.trim();
-  const characters = Array.from(normalized);
-  if (
-    normalized === ""
-    || characters.length > MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH
-    || characters.some((character) => {
-      const code = character.codePointAt(0);
-      return code !== undefined && (code <= 31 || (code >= 127 && code <= 159));
-    })
-  ) {
-    return undefined;
-  }
-  return normalized;
-}
-
-function statusFromStatusCode(statusCode) {
-  if (typeof statusCode === "number" && Number.isFinite(statusCode) && statusCode >= 400) {
-    return "failure";
-  }
-  return "success";
-}
-
-function spanStatusFromStatusCode(statusCode) {
-  if (typeof statusCode === "number" && Number.isFinite(statusCode) && statusCode >= 400) {
-    return "error";
-  }
-  return "ok";
-}
-
-function stripQueryAndHash(value) {
-  if (value === undefined || value === null) {
-    return undefined;
-  }
-  return String(value).split(/[?#]/u, 1)[0];
-}
-
-function resolveNavigationContainer(navigationContainer) {
-  if (navigationContainer && typeof navigationContainer === "object" && "current" in navigationContainer) {
-    return navigationContainer.current;
-  }
-  return navigationContainer;
-}
-
-function addNavigationListener(container, eventName, listener) {
-  const subscription = container.addListener(eventName, listener);
-  return subscriptionRemover(subscription);
-}
-
-function subscriptionRemover(subscription) {
-  if (typeof subscription === "function") {
-    return subscription;
-  }
-  if (subscription && typeof subscription.remove === "function") {
-    return () => subscription.remove();
-  }
-  return () => {};
-}
-
-function safeNavigationListener(container, eventName, listener) {
-  try {
-    return addNavigationListener(container, eventName, listener);
-  } catch {
-    return undefined;
-  }
-}
-
-function routeSnapshot(route) {
-  return {
-    key: normalizeMetadataValue(route?.key),
-    name: typeof route?.name === "string" && route.name.trim() !== "" ? route.name : undefined,
-    path: stripQueryAndHash(route?.path)
-  };
-}
-
-function navigationActionType(event) {
-  const action = event?.data?.action ?? event?.action ?? event;
-  return typeof action?.type === "string" && action.type.trim() !== "" ? action.type : undefined;
-}
-
-function traceparentForRequest({
-  init, input, randomValues, trace, traceFlags, traceparent, traceparentFactory, url
-}) {
-  const context = resolveTraceContext(trace) ?? getActiveLogBrewTrace();
-  const nextTraceparent = typeof traceparentFactory === "function"
-    ? traceparentFactory({ init, input, url })
-    : traceparent ?? (context ? createReactNativeTraceHeaders(context).traceparent : createReactNativeTraceparent({ randomValues, traceFlags }));
-  parseTraceparent(nextTraceparent);
-  return nextTraceparent;
-}
-
-export default {
-  LogBrewNativeProvider, captureAppStateChange, captureReactNativeAction, captureReactNativeError,
-  captureReactNativeNetwork, captureReactNativeNavigationSpan, captureReactNativeResourceSpan, captureScreenView,
-  bindLogBrewTrace, createAppStateListener, createLogBrewReactNativeClient, createReactNavigationSpanListener,
-  createReactNativeFetchTransport, createReactNativeSpanAttributes, createReactNativeTraceContext,
-  createReactNativeTraceHeaders, createReactNativeActionEvent,
-  createReactNativeErrorEvent, createReactNativeNetworkEvent, createReactNativeNavigationSpanEvent,
-  createReactNativeResourceSpanEvent, createReactNativeTraceparent, createTraceparentFetch, getActiveLogBrewTrace,
-  getReactNativeContext, getReactNativeTraceMetadata, shouldPropagateTraceparent, useLogBrewNative,
-  useLogBrewNativeActions, withLogBrewTrace
-};
+import runtime from "./index.cjs";
+
+export const {
+  LogBrewNativeProvider,
+  bindLogBrewTrace,
+  captureAppStateChange,
+  captureReactNativeAction,
+  captureReactNativeError,
+  captureReactNativeNavigationSpan,
+  captureReactNativeNetwork,
+  captureReactNativeResourceSpan,
+  captureScreenView,
+  createAppStateListener,
+  createLogBrewReactNativeClient,
+  createReactNavigationSpanListener,
+  createReactNativeActionEvent,
+  createReactNativeErrorEvent,
+  createReactNativeFetchTransport,
+  createReactNativeNavigationSpanEvent,
+  createReactNativeNetworkEvent,
+  createReactNativeResourceSpanEvent,
+  createReactNativeSpanAttributes,
+  createReactNativeTraceContext,
+  createReactNativeTraceHeaders,
+  createReactNativeTraceparent,
+  createTraceparentFetch,
+  getActiveLogBrewTrace,
+  getReactNativeContext,
+  getReactNativeTraceMetadata,
+  shouldPropagateTraceparent,
+  useLogBrewNative,
+  useLogBrewNativeActions,
+  withLogBrewTrace
+} = runtime;
+
+export default runtime.default;