@logbrew/react-native 0.1.20 → 0.1.21

package/README.md

@@ -347,6 +347,16 @@ clear it with `setLogBrewAppleNativeCrashContext(null)` on logout or session
 end. The crash report keeps one atomic snapshot from the crashed process, so a
 later app launch cannot replace it. Session and subject values must be opaque app-owned identifiers made from ASCII letters, numbers, `_`, or `-`. Do not use names, email addresses, IP addresses, or device identifiers. Resource context, tags, arbitrary fields, and values over the fixed 1 KiB snapshot limit fail before storage.
 
+The iOS `createLogBrewReactNativeClient()` entry also mirrors its validated
+breadcrumb history into native crash capture. Install Apple diagnostics first,
+then use the normal screen, app-state, action, network, or `addBreadcrumb()`
+helpers. A fatal crash retains the newest complete entries in oldest-to-newest
+order. The snapshot keeps at most 64 entries and 64 KiB, drops oldest entries
+when either limit is reached, and reports truncation. `clearBreadcrumbs()`
+clears both the JavaScript history and its native crash snapshot. Missing,
+corrupt, and captured breadcrumb state remains explicit on replay; corrupt
+optional context never discards the crash.
+
 Installation creates app-private, data-protected storage that iOS excludes from
 device data archives. Pending reports are partitioned by project, so changing
 the configured project does not replay an earlier project's records with the

package/apple-native-diagnostics.js

@@ -48,17 +48,31 @@ export function setLogBrewAppleNativeCrashContext(context) {
   requireApplePlatform();
   const nativeModule = requireNativeModule();
   const payload = context === null ? null : normalizeCorrelationContext(context);
-  const result = callNative(nativeModule, "setNativeDiagnosticsContext", payload);
+  return updateNativeSnapshot(nativeModule, "setNativeDiagnosticsContext", payload, "context");
+}
+
+export function syncLogBrewAppleNativeCrashBreadcrumbs(snapshot) {
+  requireApplePlatform();
+  return updateNativeSnapshot(
+    requireNativeModule(),
+    "setNativeDiagnosticsBreadcrumbs",
+    snapshot,
+    "breadcrumbs"
+  );
+}
+
+function updateNativeSnapshot(nativeModule, method, payload, label) {
+  const result = callNative(nativeModule, method, payload);
   const expectedStatus = payload === null ? "cleared" : "updated";
   if (isErrorResult(result)) {
-    throw new SdkError(result.code, `LogBrew Apple native diagnostics context failed with ${result.code}`);
+    throw new SdkError(result.code, `LogBrew Apple native diagnostics ${label} failed with ${result.code}`);
   }
   if (!isPlainObject(result)
     || Object.keys(result).length !== 1
     || result.status !== expectedStatus) {
     throw new SdkError(
       "native_diagnostics_invalid_response",
-      "LogBrew Apple native diagnostics context returned an invalid response"
+      `LogBrew Apple native diagnostics ${label} returned an invalid response`
     );
   }
   return Object.freeze({ status: expectedStatus });

package/index.cjs

@@ -16,7 +16,7 @@ const {
 } = require("./metadata.cjs");
 
 const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.20";
+const DEFAULT_SDK_VERSION = "0.1.21";
 const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
 const MAX_ACTION_NAME_LENGTH = 64;
 const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;

package/index.native.js

@@ -14,7 +14,8 @@ import {
   getLogBrewAppleNativeDiagnosticsStatus,
   installLogBrewAppleNativeDiagnostics,
   replayLogBrewAppleNativeDiagnostics,
-  setLogBrewAppleNativeCrashContext
+  setLogBrewAppleNativeCrashContext,
+  syncLogBrewAppleNativeCrashBreadcrumbs
 } from "./apple-native-diagnostics.js";
 import {
   purgeReactNativePersistentQueue,
@@ -50,7 +51,7 @@ export function createLogBrewReactNativeClient(config = {}) {
   ) && input.persistentQueue !== undefined;
   const authKey = clientKey ?? apiKey;
   if (typeof authKey !== "string" || authKey.trim() === "") {
-    return createPlatformNeutralClient(input);
+    return bindAppleNativeCrashBreadcrumbs(createPlatformNeutralClient(input));
   }
   const resolved = resolveReactNativePersistentEventStore({
     authKey,
@@ -61,20 +62,72 @@ export function createLogBrewReactNativeClient(config = {}) {
     hasExplicitPersistentQueue
   });
   try {
-    return createPlatformNeutralClient({
+    return bindAppleNativeCrashBreadcrumbs(createPlatformNeutralClient({
       ...forwarded,
       apiKey,
       clientKey,
       eventStore: resolved.eventStore,
       maxQueueBytes,
       maxQueueSize
-    });
+    }));
   } catch (error) {
     resolved.abort();
     throw error;
   }
 }
 
+function bindAppleNativeCrashBreadcrumbs(client) {
+  if (Platform?.OS !== "ios") {
+    return client;
+  }
+  const addBreadcrumb = client.addBreadcrumb.bind(client);
+  const clearBreadcrumbs = client.clearBreadcrumbs.bind(client);
+  client.addBreadcrumb = (...args) => updateAppleNativeBreadcrumbs(
+    client, () => addBreadcrumb(...args)
+  );
+  client.clearBreadcrumbs = () => updateAppleNativeBreadcrumbs(client, clearBreadcrumbs);
+  syncAppleNativeCrashBreadcrumbs(client);
+  return client;
+}
+
+function updateAppleNativeBreadcrumbs(client, update) {
+  const previous = [client.issueBreadcrumbs.slice(), client.issueBreadcrumbsTruncated];
+  const result = update();
+  try {
+    syncAppleNativeCrashBreadcrumbs(client);
+  } catch (error) {
+    restoreBreadcrumbs(client, previous);
+    throw error;
+  }
+  return result;
+}
+
+function restoreBreadcrumbs(client, [breadcrumbs, truncated]) {
+  client.issueBreadcrumbs.splice(0, client.issueBreadcrumbs.length, ...breadcrumbs);
+  client.issueBreadcrumbsTruncated = truncated;
+}
+
+function syncAppleNativeCrashBreadcrumbs(client) {
+  const snapshot = client.issueBreadcrumbs.length === 0
+    ? null
+    : {
+        breadcrumbs: client.issueBreadcrumbs.map(({ data, ...breadcrumb }) => ({
+          ...breadcrumb,
+          ...(data === undefined ? {} : { data: { ...data } })
+        })),
+        schemaVersion: 1,
+        truncated: client.issueBreadcrumbsTruncated
+      };
+  try {
+    syncLogBrewAppleNativeCrashBreadcrumbs(snapshot);
+  } catch (error) {
+    if (error?.code !== "native_diagnostics_unavailable"
+      && error?.code !== "native_diagnostics_not_installed") {
+      throw error;
+    }
+  }
+}
+
 export function purgeLogBrewReactNativePersistentQueue(config = {}) {
   purgeReactNativePersistentQueue(config);
 }

package/instrumentation.js

@@ -1,634 +1,5 @@
-import { SdkError } from "@logbrew/sdk";
-import {
-  captureReactNativeResourceSpan,
-  createReactNavigationSpanListener,
-  createReactNativeTraceContext,
-  createReactNativeTraceHeaders,
-  getActiveLogBrewTrace,
-  shouldPropagateTraceparent
-} from "./index.js";
-import { createAppStateLifecycleSpanListener } from "./lifecycle.js";
-import { createSafeReactNativeMetadata } from "./metadata.js";
-import {
-  clearLogBrewNativeBridgeScope,
-  syncLogBrewNativeBridgeScope,
-  withLogBrewNativeBridgeScope
-} from "./native-bridge.js";
-import { createReactNativeResourceFetch } from "./resource-fetch.js";
+import implementation from "./instrumentation.cjs";
 
-export function createLogBrewReactNativeInstrumentation(client, {
-  appState,
-  captureInitialLifecycleState = false,
-  captureInitialNavigationRoute = false,
-  fetchImpl,
-  globalObject = globalThis,
-  includeRouteKey = false,
-  instrumentGlobalFetch = false,
-  instrumentGlobalXMLHttpRequest = false,
-  logger,
-  measureFetchResponseBodySize = false,
-  measureXhrResponseBodySize = false,
-  metadata = {},
-  metadataFactory,
-  nativeBridge,
-  navigation,
-  navigationContainer,
-  now = () => new Date().toISOString(),
-  nowMs = () => Date.now(),
-  onError,
-  platform,
-  randomValues,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  traceFlags = "01",
-  tracePropagationTargets = []
-} = {}) {
-  requireClient(client);
-  const activeTrace = resolveInstrumentationTrace({ randomValues, trace, traceFlags });
-  const removers = [];
-  const resolvedNavigation = navigationContainer ?? navigation;
+export const { createLogBrewReactNativeInstrumentation } = implementation;
 
-  if (appState?.addEventListener) {
-    removers.push(createAppStateLifecycleSpanListener(client, appState, {
-      captureInitialState: captureInitialLifecycleState,
-      metadata,
-      now,
-      nowMs,
-      onError,
-      platform,
-      screen,
-      sessionId,
-      trace: activeTrace
-    }));
-  }
-
-  if (resolvedNavigation) {
-    removers.push(createReactNavigationSpanListener(client, resolvedNavigation, {
-      appState,
-      captureInitialRoute: captureInitialNavigationRoute,
-      includeRouteKey,
-      metadata,
-      now,
-      nowMs,
-      onError,
-      platform,
-      trace: activeTrace
-    }));
-  }
-
-  if (nativeBridge) {
-    syncLogBrewNativeBridgeScope(nativeBridge, {
-      logger,
-      metadata,
-      screen,
-      sessionId,
-      source: "react-native.instrumentation",
-      trace: activeTrace
-    });
-  }
-
-  const resourceFetch = createReactNativeResourceFetch(client, {
-    appState,
-    fetchImpl,
-    measureResponseBodySize: measureFetchResponseBodySize,
-    metadata,
-    metadataFactory,
-    now,
-    nowMs,
-    platform,
-    randomValues,
-    routeTemplate,
-    routeTemplateFactory,
-    screen,
-    sessionId,
-    trace: activeTrace,
-    traceFlags,
-    tracePropagationTargets
-  });
-  let globalFetch;
-  let globalXMLHttpRequest;
-  try {
-    globalFetch = instrumentGlobalFetch ? installGlobalFetchInstrumentation(client, {
-      appState,
-      globalObject,
-      measureFetchResponseBodySize,
-      metadata,
-      metadataFactory,
-      now,
-      nowMs,
-      platform,
-      randomValues,
-      routeTemplate,
-      routeTemplateFactory,
-      screen,
-      sessionId,
-      trace: activeTrace,
-      traceFlags,
-      tracePropagationTargets
-    }) : undefined;
-    if (globalFetch) {
-      removers.push(globalFetch.remove);
-    }
-    globalXMLHttpRequest = instrumentGlobalXMLHttpRequest ? installGlobalXMLHttpRequestInstrumentation(client, {
-      appState,
-      globalObject,
-      measureXhrResponseBodySize,
-      metadata,
-      metadataFactory,
-      now,
-      nowMs,
-      platform,
-      routeTemplate,
-      routeTemplateFactory,
-      screen,
-      sessionId,
-      trace: activeTrace,
-      tracePropagationTargets
-    }) : undefined;
-    if (globalXMLHttpRequest) {
-      removers.push(globalXMLHttpRequest.remove);
-    }
-  } catch (error) {
-    removeConfiguredInstrumentation({ nativeBridge, removers });
-    throw error;
-  }
-
-  let removed = false;
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    removeConfiguredInstrumentation({ nativeBridge, removers });
-  };
-
-  const handle = {
-    globalFetch,
-    globalXMLHttpRequest,
-    remove,
-    resourceFetch,
-    stop: remove,
-    syncNativeBridgeScope(options = {}) {
-      if (!nativeBridge) {
-        return undefined;
-      }
-      return syncLogBrewNativeBridgeScope(nativeBridge, {
-        logger,
-        metadata,
-        screen,
-        sessionId,
-        source: "react-native.instrumentation",
-        trace: activeTrace,
-        ...options
-      });
-    },
-    trace: activeTrace,
-    withNativeBridgeScope(callbackOrOptions, maybeCallback) {
-      if (!nativeBridge) {
-        throw new SdkError("configuration_error", "withNativeBridgeScope requires nativeBridge");
-      }
-      if (typeof callbackOrOptions === "function") {
-        return withLogBrewNativeBridgeScope(nativeBridge, {
-          logger,
-          metadata,
-          screen,
-          sessionId,
-          source: "react-native.instrumentation",
-          trace: activeTrace
-        }, callbackOrOptions);
-      }
-      return withLogBrewNativeBridgeScope(nativeBridge, {
-        logger,
-        metadata,
-        screen,
-        sessionId,
-        source: "react-native.instrumentation",
-        trace: activeTrace,
-        ...(callbackOrOptions ?? {})
-      }, maybeCallback);
-    }
-  };
-  return Object.freeze(handle);
-}
-
-function resolveInstrumentationTrace({ randomValues, trace, traceFlags }) {
-  if (typeof trace === "string") {
-    return createReactNativeTraceContext({ randomValues, traceFlags, traceparent: trace });
-  }
-  return trace ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext({ randomValues, traceFlags });
-}
-
-function requireClient(client) {
-  if (!client) {
-    throw new SdkError("configuration_error", "createLogBrewReactNativeInstrumentation requires a client");
-  }
-}
-
-function removeConfiguredInstrumentation({ nativeBridge, removers }) {
-  if (nativeBridge) {
-    clearLogBrewNativeBridgeScope(nativeBridge);
-  }
-  for (const removeListener of removers.splice(0).reverse()) {
-    removeListener();
-  }
-}
-
-function installGlobalFetchInstrumentation(client, {
-  appState,
-  globalObject,
-  measureFetchResponseBodySize,
-  metadata,
-  metadataFactory,
-  now,
-  nowMs,
-  platform,
-  randomValues,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  traceFlags,
-  tracePropagationTargets
-}) {
-  if ((typeof globalObject !== "object" && typeof globalObject !== "function") || globalObject === null) {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch requires a globalObject");
-  }
-  const originalFetch = globalObject.fetch;
-  if (typeof originalFetch !== "function") {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch requires globalObject.fetch");
-  }
-  const globalResourceFetch = createReactNativeResourceFetch(client, {
-    appState,
-    fetchImpl: (input, init) => originalFetch.call(globalObject, input, init),
-    measureResponseBodySize: measureFetchResponseBodySize,
-    metadata,
-    metadataFactory,
-    now,
-    nowMs,
-    platform,
-    randomValues,
-    routeTemplate,
-    routeTemplateFactory,
-    screen,
-    sessionId,
-    trace,
-    traceFlags,
-    tracePropagationTargets
-  });
-  let removed = false;
-  const wrappedFetch = (input, init) => globalResourceFetch(input, init);
-  try {
-    globalObject.fetch = wrappedFetch;
-  } catch {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch could not patch globalObject.fetch");
-  }
-  if (globalObject.fetch !== wrappedFetch) {
-    throw new SdkError("configuration_error", "instrumentGlobalFetch could not patch globalObject.fetch");
-  }
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    if (globalObject.fetch === wrappedFetch) {
-      globalObject.fetch = originalFetch;
-    }
-  };
-  return Object.freeze({
-    fetch: wrappedFetch,
-    remove,
-    stop: remove
-  });
-}
-
-/* eslint-disable no-invalid-this */
-function installGlobalXMLHttpRequestInstrumentation(client, {
-  appState,
-  globalObject,
-  measureXhrResponseBodySize,
-  metadata,
-  metadataFactory,
-  now,
-  nowMs,
-  platform,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  trace,
-  tracePropagationTargets
-}) {
-  if ((typeof globalObject !== "object" && typeof globalObject !== "function") || globalObject === null) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires a globalObject");
-  }
-  const xhrType = globalObject.XMLHttpRequest;
-  if (typeof xhrType !== "function" || !xhrType.prototype) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires globalObject.XMLHttpRequest");
-  }
-  const prototype = xhrType.prototype;
-  const originalOpen = prototype.open;
-  const originalSend = prototype.send;
-  const originalSetRequestHeader = prototype.setRequestHeader;
-  if (typeof originalOpen !== "function" || typeof originalSend !== "function" || typeof originalSetRequestHeader !== "function") {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest requires open, send, and setRequestHeader");
-  }
-
-  const contextKey = Symbol("logbrew.xhr");
-  const headersReceivedState = typeof xhrType.HEADERS_RECEIVED === "number" ? xhrType.HEADERS_RECEIVED : 2;
-  const doneState = typeof xhrType.DONE === "number" ? xhrType.DONE : 4;
-  const safeRouteTemplateFactory = routeTemplateFactory ?? defaultXhrRouteTemplateFactory;
-
-  function wrappedOpen(method, url) {
-    this[contextKey] = {
-      method: normalizeXhrMethod(method),
-      reported: false,
-      url: xhrUrl(url)
-    };
-    return originalOpen.apply(this, arguments);
-  }
-
-  function wrappedSend(body) {
-    const context = this[contextKey];
-    if (!context) {
-      return originalSend.apply(this, arguments);
-    }
-    context.body = xhrRequestBody(body);
-    context.startedAtMs = nowMs();
-    context.timestamp = now();
-    installXhrReadyStateTracker(this, context, {
-      appState,
-      client,
-      doneState,
-      headersReceivedState,
-      measureXhrResponseBodySize,
-      metadata,
-      metadataFactory,
-      nowMs,
-      platform,
-      routeTemplate,
-      routeTemplateFactory: safeRouteTemplateFactory,
-      screen,
-      sessionId,
-      trace
-    });
-    if (shouldPropagateTraceparent(context.url, tracePropagationTargets)) {
-      originalSetRequestHeader.call(this, "traceparent", createReactNativeTraceHeaders(trace).traceparent);
-    }
-    try {
-      return originalSend.apply(this, arguments);
-    } catch (error) {
-      captureXhrResourceSpan(this, context, {
-        appState,
-        client,
-        metadata: {
-          ...metadata,
-          xhrErrorName: errorName(error),
-          xhrErrorValueType: typeof error
-        },
-        metadataFactory,
-        nowMs,
-        platform,
-        routeTemplate,
-        routeTemplateFactory: safeRouteTemplateFactory,
-        screen,
-        sessionId,
-        status: "error",
-        trace
-      });
-      throw error;
-    }
-  }
-
-  prototype.open = wrappedOpen;
-  prototype.send = wrappedSend;
-  if (prototype.open !== wrappedOpen || prototype.send !== wrappedSend) {
-    throw new SdkError("configuration_error", "instrumentGlobalXMLHttpRequest could not patch XMLHttpRequest");
-  }
-
-  let removed = false;
-  const remove = () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    if (prototype.open === wrappedOpen) {
-      prototype.open = originalOpen;
-    }
-    if (prototype.send === wrappedSend) {
-      prototype.send = originalSend;
-    }
-  };
-
-  return Object.freeze({
-    remove,
-    stop: remove
-  });
-}
-
-function installXhrReadyStateTracker(xhr, context, options) {
-  const onReadyStateChange = () => {
-    if (xhr.readyState === options.headersReceivedState && context.responseStartAtMs === undefined) {
-      context.responseStartAtMs = options.nowMs();
-      return;
-    }
-    if (xhr.readyState === options.doneState && !context.reported) {
-      captureXhrResourceSpan(xhr, context, options);
-    }
-  };
-  if (typeof xhr.addEventListener === "function") {
-    xhr.addEventListener("readystatechange", onReadyStateChange);
-    return;
-  }
-  const originalOnReadyStateChange = xhr.onreadystatechange;
-  xhr.onreadystatechange = function logBrewOnReadyStateChange() {
-    onReadyStateChange();
-    if (typeof originalOnReadyStateChange === "function") {
-      return originalOnReadyStateChange.apply(this, arguments);
-    }
-    return undefined;
-  };
-}
-
-function captureXhrResourceSpan(xhr, context, {
-  appState,
-  client,
-  measureXhrResponseBodySize,
-  metadata,
-  metadataFactory,
-  nowMs,
-  platform,
-  routeTemplate,
-  routeTemplateFactory,
-  screen,
-  sessionId,
-  status,
-  trace
-}) {
-  if (context.reported) {
-    return;
-  }
-  context.reported = true;
-  const durationMs = elapsedMs(context.startedAtMs, nowMs);
-  const responseStartDurationMs = context.responseStartAtMs === undefined
-    ? undefined
-    : elapsedMs(context.startedAtMs, () => context.responseStartAtMs);
-  const responseSizeBytes = xhrResponseSizeBytes(xhr, { measureXhrResponseBodySize });
-  const safeRouteTemplate = routeTemplate ?? routeTemplateFactory({ url: context.url });
-  const statusCode = xhrStatusCode(xhr);
-  captureReactNativeResourceSpan(client, {
-    appState,
-    durationMs,
-    metadata: {
-      ...createSafeReactNativeMetadata(metadata, metadataFactory, {
-        durationMs,
-        init: context.body === undefined ? undefined : { body: context.body },
-        input: context.url,
-        method: context.method,
-        routeTemplate: safeRouteTemplate,
-        status: status ?? undefined,
-        statusCode,
-        url: context.url
-      }),
-      responseStartDurationMs,
-      transport: "xhr"
-    },
-    method: context.method,
-    platform,
-    routeTemplate: safeRouteTemplate,
-    screen,
-    responseSizeBytes,
-    sessionId,
-    status: status ?? undefined,
-    statusCode,
-    timestamp: context.timestamp,
-    trace
-  });
-}
-
-function normalizeXhrMethod(method) {
-  return String(method ?? "GET").toUpperCase();
-}
-
-function xhrUrl(url) {
-  if (typeof url === "string") {
-    return url;
-  }
-  try {
-    return url.toString();
-  } catch {
-    return String(url);
-  }
-}
-
-function xhrRequestBody(body) {
-  if (typeof body === "string") {
-    return body;
-  }
-  if (body instanceof String) {
-    return body.toString();
-  }
-  return undefined;
-}
-
-function defaultXhrRouteTemplateFactory({ 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 xhrStatusCode(xhr) {
-  return typeof xhr?.status === "number" && Number.isFinite(xhr.status) ? xhr.status : undefined;
-}
-
-function xhrResponseSizeBytes(xhr, { measureXhrResponseBodySize = false } = {}) {
-  if (typeof xhr?.getResponseHeader !== "function") {
-    return measureXhrResponseBodySize ? xhrResponseBodySizeBytes(xhr) : undefined;
-  }
-  const contentLength = Number.parseInt(String(xhr.getResponseHeader("Content-Length") ?? ""), 10);
-  if (Number.isFinite(contentLength) && contentLength >= 0) {
-    return contentLength;
-  }
-  return measureXhrResponseBodySize ? xhrResponseBodySizeBytes(xhr) : undefined;
-}
-
-function xhrResponseBodySizeBytes(xhr) {
-  const responseType = readXhrResponseValue(xhr, "responseType");
-  if (responseType === undefined || responseType === "" || responseType === "text") {
-    const responseText = readXhrResponseValue(xhr, "responseText");
-    if (typeof responseText === "string" || responseText instanceof String) {
-      return utf8ByteLength(responseText.toString());
-    }
-  }
-  const response = readXhrResponseValue(xhr, "response");
-  if (typeof response === "string" || response instanceof String) {
-    return utf8ByteLength(response.toString());
-  }
-  if (typeof ArrayBuffer === "function") {
-    if (response instanceof ArrayBuffer) {
-      return response.byteLength;
-    }
-    if (typeof ArrayBuffer.isView === "function" && ArrayBuffer.isView(response)) {
-      return response.byteLength;
-    }
-  }
-  if (typeof response?.size === "number" && Number.isFinite(response.size) && response.size >= 0) {
-    return response.size;
-  }
-  return undefined;
-}
-
-function readXhrResponseValue(xhr, property) {
-  try {
-    return xhr?.[property];
-  } catch {
-    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";
-}
-/* eslint-enable no-invalid-this */
-
-export default {
-  createLogBrewReactNativeInstrumentation
-};
+export default implementation.default;

package/ios/AppleDiagnostics/LBRNAppleDiagnosticsModule.mm

@@ -45,6 +45,11 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(setNativeDiagnosticsContext:(NSDictionary
     return [LBRNAppleNativeDiagnostics setCorrelationContext:context];
 }
 
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(setNativeDiagnosticsBreadcrumbs:(NSDictionary *)snapshot)
+{
+    return [LBRNAppleNativeDiagnostics setBreadcrumbs:snapshot];
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(nativeDiagnosticsStatus)
 {
     return [LBRNAppleNativeDiagnostics status];

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.20"
+    private static let sdkVersion = "0.1.21"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")
@@ -44,6 +44,11 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
         shared.updateCorrelationContext(rawContext)
     }
 
+    @objc(setBreadcrumbs:)
+    public static func setBreadcrumbs(_ rawSnapshot: NSDictionary?) -> NSDictionary {
+        shared.updateBreadcrumbs(rawSnapshot)
+    }
+
     private func installOnMainThread(_ rawConfiguration: NSDictionary) -> NSDictionary {
         guard let configuration = InstalledConfiguration(rawConfiguration) else {
             return failure("native_diagnostics_invalid_configuration")
@@ -154,6 +159,26 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
         }
     }
 
+    private func updateBreadcrumbs(_ rawSnapshot: NSDictionary?) -> NSDictionary {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let capture else {
+            return failure("native_diagnostics_not_installed")
+        }
+        do {
+            let snapshot = try rawSnapshot.map { try NativeCrashBreadcrumbs.validated($0) }
+            try capture.setBreadcrumbs(
+                snapshot?.breadcrumbs,
+                truncated: snapshot?.truncated ?? false,
+            )
+            return ["status": rawSnapshot == nil ? "cleared" : "updated"]
+        } catch let error as NativeCrashError {
+            return failure(error.code.rawValue)
+        } catch {
+            return failure("native_diagnostics_failed")
+        }
+    }
+
     private func captureStatus(status: String) -> NSDictionary {
         guard let capture else {
             return failure("native_diagnostics_not_installed")

package/ios/GeneratedAppleDiagnostics/LogBrew/IssueDiagnostics.swift

@@ -174,7 +174,7 @@ final class IssueBreadcrumbStore: @unchecked Sendable {
     }
 }
 
-let maximumIssueBreadcrumbs = 64
+@_spi(CrashReplay) public let maximumIssueBreadcrumbs = 64
 
 func normalizeIssueAttributes(_ value: IssueAttributes) throws -> IssueAttributes {
     let exception = try value.exception.map(validateIssueException)
@@ -251,7 +251,8 @@ func validateIssueException(_ value: IssueException) throws -> IssueException {
     return IssueException(type: exceptionType, mechanism: mechanism)
 }
 
-func validateIssueBreadcrumb(_ value: IssueBreadcrumb) throws -> IssueBreadcrumb {
+@_spi(CrashReplay)
+public func validateIssueBreadcrumb(_ value: IssueBreadcrumb) throws -> IssueBreadcrumb {
     try requireTimestamp(value.timestamp)
     guard validMachineKey(value.category, maximum: 64, separators: ["_", ".", ":", "-"]) else {
         throw issueValidationError("issue breadcrumb category is invalid")

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/CrashReportSanitizer.swift

@@ -23,6 +23,7 @@ struct CrashReportSanitizer {
         let nativeStackFrames = NativeStackFrameSanitizer().frames(from: rawReport)
         let artifactIdentity = try NativeArtifactIdentityValue.persistedIdentity(in: rawReport)
         let correlation = NativeCrashCorrelation.captured(in: rawReport)
+        let breadcrumbs = NativeCrashBreadcrumbs.captured(in: rawReport)
         return NativeCrashRecord(
             eventID: uuid.uuidString.lowercased(),
             timestamp: timestamp.normalized,
@@ -35,6 +36,9 @@ struct CrashReportSanitizer {
                 correlation: correlation.0,
             ),
             correlationState: correlation.1,
+            breadcrumbs: breadcrumbs.0?.breadcrumbs,
+            breadcrumbsTruncated: breadcrumbs.0?.truncated,
+            breadcrumbState: breadcrumbs.1,
             hangState: nil,
             hangDurationMs: nil,
             source: .engine(reportID: reportID),

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCapture.swift

@@ -122,6 +122,25 @@ public final class NativeCrashCapture: NSObject, @unchecked Sendable {
         )
     }
 
+    /// Replaces the crash-time breadcrumb snapshot in one bounded write.
+    @nonobjc
+    public func setBreadcrumbs(
+        _ breadcrumbs: [IssueBreadcrumb]?,
+        truncated: Bool = false,
+    ) throws {
+        lock.lock()
+        defer { lock.unlock() }
+        try verifyProcessLocked()
+        guard store != nil, lifecycle != .stopped else {
+            throw NativeCrashError(.notInstalled)
+        }
+        try verifyStorageLocked()
+        try driver.setUserInfo(
+            NativeCrashBreadcrumbs.encoded(breadcrumbs, truncated: truncated),
+            forKey: NativeCrashBreadcrumbs.reportKey,
+        )
+    }
+
     @objc(replayPendingReportsWithHandler:error:)
     public func replayPendingReports(
         _ handler: (NativeCrashRecord) -> Bool,

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCorrelation.swift

@@ -2,7 +2,7 @@
 // Edit the canonical Swift source, then regenerate this package boundary.
 import Foundation
 
-enum NativeCrashCorrelationState: String {
+enum NativeCrashContextState: String {
     case captured
     case notCaptured = "not_captured"
     case unavailable
@@ -22,14 +22,12 @@ enum NativeCrashCorrelation {
                 throw NativeCrashError(.invalidConfiguration)
             }
             return value
-        } catch let error as NativeCrashError {
-            throw error
         } catch {
             throw NativeCrashError(.invalidConfiguration)
         }
     }
 
-    static func captured(in rawReport: [String: Any]) -> (TelemetryContext?, NativeCrashCorrelationState) {
+    static func captured(in rawReport: [String: Any]) -> (TelemetryContext?, NativeCrashContextState) {
         guard let user = rawReport["user"] as? [String: Any], let value = user[reportKey] else {
             return (nil, .notCaptured)
         }
@@ -75,3 +73,102 @@ enum NativeCrashCorrelation {
         return encoder
     }
 }
+
+struct NativeCrashBreadcrumbSnapshot: Codable, Equatable {
+    let schemaVersion: Int
+    let breadcrumbs: [IssueBreadcrumb]
+    let truncated: Bool
+
+    init(breadcrumbs: [IssueBreadcrumb], truncated: Bool) {
+        schemaVersion = 1
+        self.breadcrumbs = breadcrumbs
+        self.truncated = truncated
+    }
+}
+
+enum NativeCrashBreadcrumbs {
+    static let reportKey = "logbrew_native_breadcrumbs"
+    static let maximumBytes = 64 * 1024
+
+    static func encoded(_ values: [IssueBreadcrumb]?, truncated: Bool) throws -> String? {
+        guard let values, !values.isEmpty else {
+            return nil
+        }
+        do {
+            var breadcrumbs = try values.suffix(maximumIssueBreadcrumbs).map(validateIssueBreadcrumb)
+            var wasTruncated = truncated || breadcrumbs.count < values.count
+            while !breadcrumbs.isEmpty {
+                let data = try encoder().encode(NativeCrashBreadcrumbSnapshot(
+                    breadcrumbs: breadcrumbs,
+                    truncated: wasTruncated,
+                ))
+                if data.count <= maximumBytes, let value = String(data: data, encoding: .utf8) {
+                    return value
+                }
+                breadcrumbs.removeFirst()
+                wasTruncated = true
+            }
+        } catch let error as NativeCrashError {
+            throw error
+        } catch {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        throw NativeCrashError(.invalidConfiguration)
+    }
+
+    static func captured(
+        in rawReport: [String: Any],
+    ) -> (NativeCrashBreadcrumbSnapshot?, NativeCrashContextState) {
+        guard let user = rawReport["user"] as? [String: Any], let value = user[reportKey] else {
+            return (nil, .notCaptured)
+        }
+        guard let value = value as? String,
+              let data = value.data(using: .utf8),
+              data.count <= maximumBytes,
+              let object = try? JSONSerialization.jsonObject(with: data),
+              let snapshot = try? validated(object)
+        else {
+            return (nil, .unavailable)
+        }
+        return (snapshot, .captured)
+    }
+
+    static func validated(_ object: Any) throws -> NativeCrashBreadcrumbSnapshot {
+        do {
+            guard JSONSerialization.isValidJSONObject(object) else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            let data = try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
+            guard data.count <= maximumBytes else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            let decoded = try JSONDecoder().decode(NativeCrashBreadcrumbSnapshot.self, from: data)
+            guard decoded.schemaVersion == 1,
+                  !decoded.breadcrumbs.isEmpty,
+                  decoded.breadcrumbs.count <= maximumIssueBreadcrumbs
+            else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            let snapshot = try NativeCrashBreadcrumbSnapshot(
+                breadcrumbs: decoded.breadcrumbs.map(validateIssueBreadcrumb),
+                truncated: decoded.truncated,
+            )
+            let normalized = try encoder().encode(snapshot)
+            let normalizedObject = try JSONSerialization.jsonObject(with: normalized)
+            guard object as? NSDictionary == normalizedObject as? NSDictionary else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            return snapshot
+        } catch let error as NativeCrashError {
+            throw error
+        } catch {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+    }
+
+    private static func encoder() -> JSONEncoder {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
+        return encoder
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashPublic.swift

@@ -164,7 +164,10 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
     private let nativeStackFrames: [NativeStackFrame]?
     private let artifactIdentity: NativeArtifactIdentity?
     private let context: TelemetryContext?
-    private let correlationState: NativeCrashCorrelationState?
+    private let correlationState: NativeCrashContextState?
+    private let breadcrumbs: [IssueBreadcrumb]?
+    private let breadcrumbsTruncated: Bool?
+    private let breadcrumbState: NativeCrashContextState?
     private let hangState: NativeHangIncidentState?
     private let hangDurationMs: Double?
     let source: NativeCrashRecordSource
@@ -178,7 +181,10 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         nativeStackFrames: [NativeStackFrame]?,
         artifactIdentity: NativeArtifactIdentity?,
         context: TelemetryContext?,
-        correlationState: NativeCrashCorrelationState? = nil,
+        correlationState: NativeCrashContextState? = nil,
+        breadcrumbs: [IssueBreadcrumb]? = nil,
+        breadcrumbsTruncated: Bool? = nil,
+        breadcrumbState: NativeCrashContextState? = nil,
         hangState: NativeHangIncidentState?,
         hangDurationMs: Double? = nil,
         source: NativeCrashRecordSource,
@@ -192,6 +198,9 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         self.artifactIdentity = artifactIdentity
         self.context = context
         self.correlationState = correlationState
+        self.breadcrumbs = breadcrumbs
+        self.breadcrumbsTruncated = breadcrumbsTruncated
+        self.breadcrumbState = breadcrumbState
         self.hangState = hangState
         self.hangDurationMs = hangDurationMs
         self.source = source
@@ -234,6 +243,9 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         if let correlationState {
             metadata["crash.correlation"] = .string(correlationState.rawValue)
         }
+        if let breadcrumbState {
+            metadata["crash.breadcrumbs"] = .string(breadcrumbState.rawValue)
+        }
         if let hangState {
             metadata["crash.handled"] = .bool(hangState == .recovered)
         }
@@ -245,6 +257,8 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
             level: hangState == .recovered ? .error : .fatal,
             exception: issueException,
             exceptionChain: nativeCrashExceptionChain(for: issueException),
+            breadcrumbs: breadcrumbs,
+            breadcrumbsTruncated: breadcrumbsTruncated,
             metadata: metadata,
             context: context,
             nativeStackFrames: nativeStackFrames,
@@ -287,12 +301,16 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         else {
             return false
         }
-        for legacyField in ["exception", "exceptionChain", "context"] where actual[legacyField] == nil {
+        let legacyFields = ["exception", "exceptionChain", "breadcrumbs", "breadcrumbsTruncated", "context"]
+        for legacyField in legacyFields where actual[legacyField] == nil {
             expected.removeValue(forKey: legacyField)
         }
-        if (actual["metadata"] as? [String: Any])?["crash.correlation"] == nil {
+        let actualMetadata = actual["metadata"] as? [String: Any]
+        if actualMetadata?["crash.correlation"] == nil || actualMetadata?["crash.breadcrumbs"] == nil {
             var metadata = expected["metadata"] as? [String: Any]
-            metadata?.removeValue(forKey: "crash.correlation")
+            for key in ["crash.correlation", "crash.breadcrumbs"] where actualMetadata?[key] == nil {
+                metadata?.removeValue(forKey: key)
+            }
             expected["metadata"] = metadata
         }
         return actual as NSDictionary == expected as NSDictionary

package/ios/GeneratedAppleDiagnostics/SOURCE-MANIFEST.json

@@ -11,7 +11,7 @@
     "swift/logbrew-swift/Sources/LogBrew/DurableDeliveryStoreRecovery.swift": "79fee27975b6571954bf0b3692a50e60bbbcf53b5ab47f653a474db5c56d68ba",
     "swift/logbrew-swift/Sources/LogBrew/EventEncoding.swift": "b88b6b2d17f7d0cee9ac1a1f34ef35b192cd33d213ef3c9e1c2d21cbcc304a97",
     "swift/logbrew-swift/Sources/LogBrew/IssueDiagnosticEvidence.swift": "e471f27fadaefe06971c1a98892aeb0774e840a2ce0cbb243ae9aabfa41b1c47",
-    "swift/logbrew-swift/Sources/LogBrew/IssueDiagnostics.swift": "297b8bbefd42c314a984fecb38237fb1395700c9eafcfdd1b545267bc34294cc",
+    "swift/logbrew-swift/Sources/LogBrew/IssueDiagnostics.swift": "bbdfe6169961ff27b8f2cee63c7dcdeacf2e5cee6a3ca17f6a26b933f0adfc39",
     "swift/logbrew-swift/Sources/LogBrew/IssueExceptionChain.swift": "10f81cbce95b47da0a44ef9e515b150e60d71dfcc8b04be24b037b1222a373a5",
     "swift/logbrew-swift/Sources/LogBrew/LifecycleTrace.swift": "738cd3f129fac821a892404d1d42ee92bd806b6583d3dbb5379e88b14ab23c16",
     "swift/logbrew-swift/Sources/LogBrew/LogBrewClient.swift": "186cdbda3754a811f17b82818ca8e7a1711b3b75123686cd17dc3b7441fa21cb",
@@ -29,13 +29,13 @@
     "swift/logbrew-swift/Sources/LogBrew/URLSessionTracer.swift": "0cdf08f92d6111c0dc2883b87837b81f69b5c2f9a8e5501780a114c23a741af7",
     "swift/logbrew-swift/Sources/LogBrew/Validation.swift": "07ff5c2daeb829b1df4f50edb0b79727f9a81b1c9b5cde5f995f5ad6ce660aa7",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashEngine.swift": "a94dfce653e3e7f381be42b6d2c4540f0be77e83777ecc53e06682cd2e569c5a",
-    "swift/logbrew-swift/Sources/LogBrewCrash/CrashReportSanitizer.swift": "5b503240977bd0c266035b2024e16c50846e6d2932dea083182bc549192a804f",
+    "swift/logbrew-swift/Sources/LogBrewCrash/CrashReportSanitizer.swift": "ccd0ef83f14096816765278e007f5e4ba0a40286ce00d708b38ca0b94959171e",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashStorageDirectory.swift": "7cd566703cbf704dc99155451ee93dcace12c35c805abc09a6dcf23975cf43f9",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeArtifactIdentity.swift": "3d785ad717dcf7302451531c18b5e1183983270a6cd78dd543a407e3facc6ae0",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCapture.swift": "3ebecef96e67b8e5a56a10d0d847470cb276dea44164e2e637584e110ea3ea39",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCorrelation.swift": "a513d933eea0b4e83418eb5dd60086cc6871c9e0147a6e7224c45cc6b502de2e",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCapture.swift": "c2f5d0e9a8953cb988633ebf60a06f3b7ddaa0c9828f99372969fdfb60b99bc4",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCorrelation.swift": "eef19c6e561bc03bb4c09736722afe57f63d557f9279b26353679bd53362c25d",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashExceptionEvidence.swift": "ce191e46298d91d87b379528d610caa88b924b15a8dd912b4a164b51eb172a7a",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "1672116a06fbdd10971838817591ee23af68bd5a9b07bbffb073e0fafc6cb1c0",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "2d0f2e7cdce09dc09906cede5d83928e8bd0e70a8522ff55c999d19366d84730",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashReplay.swift": "3eb3d93b32cf14de416f56fa30d6d65e6f268b5ec9d1a67081d7525c4efd4f80",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeHangIncidentStore.swift": "5a8150083f16d6b495c9c63434809dc5f11f13ebb23211f57151bad62040781b",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeHangWatchdog.swift": "37b25904cd6576e20c40500be2c153156403b57ad7b4186a1b6b35b414145ecb",

package/metadata.js

@@ -1,181 +1,10 @@
-const SENSITIVE_METADATA_FACTORY_KEY_RE = new RegExp([
-  "body",
-  "payload",
-  "variable",
-  "header",
-  "authorization",
-  "cookie",
-  "to\u006ben",
-  "sec\u0072et",
-  "pass\u0077ord"
-].join("|"), "u");
-const REACT_NATIVE_DEBUG_ID_REGISTRY = Symbol.for("@logbrew/react-native/debug-ids");
-const SAFE_RELEASE_ARTIFACT_DEBUG_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-const MAX_REACT_NATIVE_DEBUG_ID_REGISTRY_ENTRIES = 64;
-const MAX_REACT_NATIVE_DEBUG_ID_REGISTRY_FRAMES = 128;
-
-export function createSafeReactNativeMetadata(metadata, metadataFactory, context) {
-  if (typeof metadataFactory !== "function") {
-    return metadata;
-  }
-  return {
-    ...metadata,
-    ...safeReactNativeMetadataFactoryResult(metadataFactory(context))
-  };
-}
-
-export function safeReactNativeMetadataFactoryResult(candidate) {
-  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
-    return {};
-  }
-  const metadata = {};
-  for (const [key, value] of Object.entries(candidate)) {
-    if (isSensitiveMetadataKey(key)) {
-      continue;
-    }
-    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      metadata[key] = value;
-    }
-  }
-  return metadata;
-}
-
-export function sanitizeReactNativeIssueMetadata(metadata, compactMetadata) {
-  const next = { ...metadata };
-  for (const key of ["errorFrameFile", "releaseArtifactCodeFile"]) {
-    const path = reactNativeCodePath(next[key]);
-    if (path) {
-      next[key] = path;
-    }
-  }
-  const match = typeof next.issueGroupingKey === "string" ? next.issueGroupingKey.match(/^([^:]+):([^:]+):(.+)$/u) : null;
-  const path = match ? reactNativeCodePath(match[3]) : undefined;
-  if (path) {
-    next.issueGroupingKey = `${match[1]}:${match[2]}:${path}`;
-  }
-  return compactMetadata(next);
-}
-
-export function sanitizeReactNativeIssueStackFrames(stackFrames) {
-  if (!Array.isArray(stackFrames)) {
-    return undefined;
-  }
-  return stackFrames.map((frame) => ({
-    ...frame,
-    filename: reactNativeCodePath(frame.filename) ?? frame.filename
-  }));
-}
-
-export function sanitizeReactNativeIssueExceptionChain(exceptionChain) {
-  if (!exceptionChain || !Array.isArray(exceptionChain.entries)) {
-    return undefined;
-  }
-  return {
-    ...exceptionChain,
-    entries: exceptionChain.entries.map((entry) => {
-      const stackFrames = sanitizeReactNativeIssueStackFrames(entry.stackFrames);
-      return {
-        ...entry,
-        ...(stackFrames ? { stackFrames } : {})
-      };
-    })
-  };
-}
-
-export function runtimeReactNativeDebugIdMap() {
-  try {
-    const registry = globalThis?.[REACT_NATIVE_DEBUG_ID_REGISTRY];
-    if (!registry || Array.isArray(registry) || typeof registry !== "object") {
-      return undefined;
-    }
-    const entries = Object.entries(registry);
-    if (entries.length === 0 || entries.length > MAX_REACT_NATIVE_DEBUG_ID_REGISTRY_ENTRIES) {
-      return undefined;
-    }
-    const debugIdMap = Object.create(null);
-    let frameCount = 0;
-    for (const [stack, debugId] of entries) {
-      if (typeof debugId !== "string" || !SAFE_RELEASE_ARTIFACT_DEBUG_ID.test(debugId)) {
-        return undefined;
-      }
-      const normalizedDebugId = debugId.toLowerCase();
-      let stackFrameCount = 0;
-      for (const line of stack.split(/\r?\n/u)) {
-        const filename = runtimeStackFrameFilename(line);
-        if (!filename) {
-          continue;
-        }
-        frameCount += 1;
-        stackFrameCount += 1;
-        if (frameCount > MAX_REACT_NATIVE_DEBUG_ID_REGISTRY_FRAMES) {
-          return undefined;
-        }
-        const existingDebugId = debugIdMap[filename];
-        if (existingDebugId && existingDebugId !== normalizedDebugId) {
-          return undefined;
-        }
-        debugIdMap[filename] = normalizedDebugId;
-      }
-      if (stackFrameCount === 0) {
-        return undefined;
-      }
-    }
-    return frameCount > 0 ? debugIdMap : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function isSensitiveMetadataKey(key) {
-  return SENSITIVE_METADATA_FACTORY_KEY_RE.test(String(key).toLowerCase());
-}
-
-function runtimeStackFrameFilename(rawLine) {
-  let location = typeof rawLine === "string" ? rawLine.trim() : "";
-  if (!location) {
-    return undefined;
-  }
-  if (location.startsWith("at ")) {
-    location = location.slice(3).trim();
-    if (location.endsWith(")") && location.includes("(")) {
-      location = location.slice(location.lastIndexOf("(") + 1, -1);
-    }
-  } else if (location.includes("@")) {
-    location = location.slice(location.lastIndexOf("@") + 1);
-  }
-  const parts = location.split(":");
-  if (parts.length < 3) {
-    return undefined;
-  }
-  const columnText = parts.pop();
-  const lineText = parts.pop();
-  const filename = parts.join(":").trim();
-  if (!/^[1-9]\d*$/u.test(lineText) || !/^[1-9]\d*$/u.test(columnText)) {
-    return undefined;
-  }
-  const line = Number(lineText);
-  const column = Number(columnText);
-  return Number.isSafeInteger(line) && Number.isSafeInteger(column) && filename ? filename : undefined;
-}
-
-function reactNativeCodePath(value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return undefined;
-  }
-  let path = value.trim();
-  const URLConstructor = globalThis.URL;
-  if (typeof URLConstructor === "function") {
-    try {
-      path = new URLConstructor(path).pathname || path;
-    } catch {
-      path = path.split(/[?#]/u, 1)[0].replace(/\\/g, "/");
-    }
-  } else {
-    path = path.split(/[?#]/u, 1)[0].replace(/\\/g, "/");
-  }
-  if (/^[A-Za-z]:\//u.test(path) || /^\/(?:Users|home|private|tmp|var)\//u.test(path)) {
-    path = path.replace(/\/+$/u, "");
-    return path.slice(path.lastIndexOf("/") + 1) || undefined;
-  }
-  return path || undefined;
-}
+import implementation from "./metadata.cjs";
+
+export const {
+  createSafeReactNativeMetadata,
+  runtimeReactNativeDebugIdMap,
+  safeReactNativeMetadataFactoryResult,
+  sanitizeReactNativeIssueExceptionChain,
+  sanitizeReactNativeIssueMetadata,
+  sanitizeReactNativeIssueStackFrames
+} = implementation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/react-native",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "React Native offline delivery, Apple native diagnostics, screen, error, trace, action, and network timeline helpers for LogBrew.",
   "type": "module",
   "main": "./index.cjs",
@@ -240,7 +240,7 @@
     "url": "git+https://github.com/LogBrewCo/sdk.git"
   },
   "peerDependencies": {
-    "@logbrew/sdk": "^0.1.12",
+    "@logbrew/sdk": "^0.1.15",
     "expo": ">=49",
     "react": ">=18",
     "react-native": ">=0.72"

package/src/NativeLogBrewAppleDiagnostics.ts

@@ -9,6 +9,9 @@ export interface Spec extends TurboModule {
   setNativeDiagnosticsContext(
     context: CodegenTypes.UnsafeObject | null
   ): CodegenTypes.UnsafeObject;
+  setNativeDiagnosticsBreadcrumbs(
+    snapshot: CodegenTypes.UnsafeObject | null
+  ): CodegenTypes.UnsafeObject;
   nativeDiagnosticsStatus(): CodegenTypes.UnsafeObject;
 }