@logbrew/react-native 0.1.11 → 0.1.12

package/LogBrewReactNative.podspec

@@ -12,11 +12,33 @@ Pod::Spec.new do |spec|
   spec.platforms = { :ios => "13.0" }
   spec.source = {
     :git => "https://github.com/LogBrewCo/sdk.git",
-    :tag => "react-native-v#{spec.version}"
+    :tag => "js/logbrew-react-native/v#{spec.version}"
   }
-  spec.source_files = "ios/**/*.{h,m,mm}"
-  spec.exclude_files = "ios/Tests/**/*"
+  spec.default_subspecs = "Core"
+  spec.swift_versions = ["5.0"]
   spec.dependency "React-Core"
 
+  spec.subspec "Core" do |core|
+    core.source_files = "ios/**/*.{h,m,mm}"
+    core.exclude_files = [
+      "ios/AppleDiagnostics/**/*",
+      "ios/Tests/**/*"
+    ]
+  end
+
+  spec.subspec "AppleNativeDiagnostics" do |diagnostics|
+    diagnostics.ios.deployment_target = "15.0"
+    diagnostics.source_files = [
+      "ios/AppleDiagnostics/**/*.{h,m,mm,swift}",
+      "ios/GeneratedAppleDiagnostics/**/*.swift"
+    ]
+    diagnostics.dependency "#{spec.name}/Core"
+    diagnostics.dependency "KSCrash/Recording", "2.5.1"
+    diagnostics.pod_target_xcconfig = {
+      "DEFINES_MODULE" => "YES",
+      "SWIFT_VERSION" => "5.0"
+    }
+  end
+
   install_modules_dependencies(spec) if respond_to?(:install_modules_dependencies, true)
 end

package/README.md

@@ -6,7 +6,7 @@
 
 React Native helpers for the public LogBrew JavaScript SDK.
 
-This package is intentionally thin. It keeps all event validation, retry, flush, and shutdown behavior in `@logbrew/sdk`, while adding mobile-friendly helpers for screen views, app-state changes, product actions, API milestones, handled JavaScript errors, opt-in Hermes Promise rejection tracking, app-owned Promise rejection callbacks, provider/hook usage, active W3C trace correlation, explicit W3C trace propagation, opt-in lifecycle spans, opt-in resource fetch spans, opt-in reversible global fetch spans, app-owned native bridge scope sync, and reversible instrumentation setup.
+This package keeps event validation, retry, flush, and shutdown behavior in `@logbrew/sdk`. It adds mobile helpers for screen views, app-state changes, product actions, API milestones, bounded issue breadcrumbs, typed handled and unhandled JavaScript errors, Promise rejection tracking, provider and hook usage, W3C trace correlation and propagation, lifecycle spans, resource spans, reversible instrumentation, and opt-in Apple native crash and app-hang diagnostics.
 
 ## Install
 
@@ -227,7 +227,7 @@ withLogBrewTrace(trace, () => {
 
 ## Error Capture
 
-Use `captureReactNativeError()` in app-owned error boundaries, route handlers, async catch blocks, or global handlers. It records handled JavaScript errors as LogBrew issue events with React Native context and omits stack text by default:
+Use `captureReactNativeError()` in app-owned error boundaries, route handlers, async catch blocks, or global handlers. It records a typed exception with `react-native.error`, `handled: true`, prior screen/app-state/action/network breadcrumbs, and React Native context. Global errors and Promise rejections use their own mechanism with `handled: false`. Raw stack text stays omitted by default:
 
 ```js
 import { captureReactNativeError } from "@logbrew/react-native";
@@ -271,6 +271,100 @@ The React Native conditional export obtains LogBrew's synchronous native fatal s
 
 Automatic events exclude the original error message, raw stack, arbitrary metadata, full URLs, hosts, query strings, local absolute paths, payloads, and native error text. `onDiagnostic` receives only a fixed code. This error-handler integration does not claim mathematically exactly-once delivery, native crash capture, ANR or hang detection, general offline queueing by the fatal-record slot, or symbolication. The client-level persistent queue above owns normal event restart delivery.
 
+### Apple native crash and app-hang diagnostics
+
+Apple native diagnostics are an iOS-only, opt-in build feature. They capture a
+fatal native process crash and replay one privacy-bounded issue after the next
+launch. Set `hangThresholdSeconds` to also capture recovered or ongoing UIKit
+main-thread hangs. Android native crash and ANR capture are not included.
+
+For Expo prebuild or development builds, add the config plugin:
+
+```json
+{
+  "expo": {
+    "plugins": ["@logbrew/react-native/expo"]
+  }
+}
+```
+
+Then run your normal Expo prebuild or EAS build. Expo Go cannot load this native
+module. For a bare React Native app, add the optional subspec inside the app
+target in `ios/Podfile`, then run `pod install`:
+
+```ruby
+logbrew_react_native_path = File.dirname(`node --print "require.resolve('@logbrew/react-native')"`)
+pod 'LogBrewReactNative/AppleNativeDiagnostics', :path => logbrew_react_native_path
+```
+
+The default `LogBrewReactNative/Core` subspec remains unchanged and supports
+iOS 13. `AppleNativeDiagnostics` requires iOS 15. Install it on the main thread
+before root registration, then start replay:
+
+```js
+import {
+  installLogBrewAppleNativeDiagnostics,
+  replayLogBrewAppleNativeDiagnostics
+} from "@logbrew/react-native/apple-native-diagnostics";
+
+const nativeStatus = installLogBrewAppleNativeDiagnostics({
+  clientKey: process.env.EXPO_PUBLIC_LOGBREW_CLIENT_KEY,
+  projectId: "550e8400-e29b-41d4-a716-446655440000",
+  release: "com.example.app@1.2.3+45",
+  environment: "production",
+  service: "ios-app",
+  fatalHandlerOwnership: "logbrew",
+  hangThresholdSeconds: 2
+});
+
+void replayLogBrewAppleNativeDiagnostics().catch((error) => {
+  console.warn(error?.code ?? "native_diagnostics_failed");
+});
+```
+
+`fatalHandlerOwnership: "logbrew"` is an explicit process-lifetime ownership
+claim. Do not install these diagnostics while Sentry or another integration
+owns the native fatal signal or Mach exception handlers. Linking both SDKs is
+allowed, but only one integration may install native fatal capture in a given
+process. LogBrew cannot transfer or remove that ownership before process
+restart.
+
+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
+new project's key. The raw local KSCrash report can still contain sensitive
+process details, so apply the app's consent and retention policy to it. Hosted
+replay uploads only the bounded crash or hang issue described by the Swift
+`LogBrewCrash` contract. Status and error results expose fixed codes and bounded
+counters, not keys, paths, raw reports, or native error text. A custom endpoint
+must be a plain HTTPS path without embedded authentication, a query, or a fragment.
+
+Use the same project, release, environment, and service values for the runtime
+and its Apple dSYM. After signing in with `logbrew login`, upload and inspect
+the exact debug object with the released CLI:
+
+```bash
+logbrew debug-artifacts upload ios/build/MyApp.app.dSYM \
+  --project 550e8400-e29b-41d4-a716-446655440000 \
+  --release com.example.app@1.2.3+45 \
+  --environment production \
+  --service ios-app \
+  --json
+
+logbrew debug-artifacts lookup \
+  --project 550e8400-e29b-41d4-a716-446655440000 \
+  --release com.example.app@1.2.3+45 \
+  --environment production \
+  --service ios-app \
+  --image-uuid <mach_o_uuid> \
+  --architecture arm64 \
+  --json
+```
+
+The SDK does not upload debug objects during a build or at runtime. Hosted
+symbolication begins only after the exact Mach-O UUID and architecture lookup
+succeeds.
+
 ### Opt-in Hermes Promise rejection tracking
 
 React Native exposes one Promise rejection tracker slot. Claim it explicitly
@@ -454,6 +548,8 @@ 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.
 
 ## Trace Propagation
@@ -781,7 +877,14 @@ uploadLogBrewReactNativeReleaseArtifacts({
 
 The helper requires explicit `release`, `environment`, `service`, and `platform` metadata. Hosted uploads also require a UUID `projectId`; local preparation and loopback upload remain valid without it. It defaults minified bundle URLs to `app:///react-native/<platform>/...`, removes query strings and hashes from manifest URLs, and strips source paths under `root` or `stripSourcePrefix`. Hosted endpoints must use HTTPS and must not include embedded auth values, query strings, or fragments. The helper never uses normal SDK ingest keys or account/session API auth values. When `sourcemap` points at a final Hermes-composed map, the helper makes the bundle's `sourceMappingURL` point at that explicit map, so stale packager-map comments do not block manifest generation. The explicit Metro wrapper changes only app-owned serialization and one bounded runtime Debug-ID registry; neither helper patches Gradle, Xcode, global fetch/XHR, request payloads, or transport behavior.
 
-React Native native symbols are handled as release artifacts, not runtime telemetry. For local dry-run validation, use the repo release-artifact tooling against app-owned build outputs such as `ios/build/.../*.dSYM`, `android/app/build/outputs/mapping/release/mapping.txt`, and `android/app/build/intermediates/merged_native_libs/.../*.so`. The current public SDK validates metadata and privacy boundaries only; backend upload, storage, lookup, and native symbolication are still backend-owned future support, so do not rely on normal runtime error capture for native crash symbolication yet.
+React Native native symbols are release artifacts, not runtime telemetry. Use
+the repository release-artifact tooling for local dry-run checks of app-owned
+outputs such as `ios/build/.../*.dSYM`, Android mapping files, and native shared
+objects. Apple dSYM upload, storage, exact UUID and architecture lookup, and
+hosted symbolication are available through `logbrew debug-artifacts`. The SDK
+does not upload those artifacts automatically. Normal JavaScript error capture
+does not produce native crash symbolication; use the opt-in Apple diagnostics
+flow above with an exact uploaded dSYM.
 
 ## Example Source
 

package/apple-native-diagnostics.d.ts

@@ -0,0 +1,52 @@
+type LogBrewAppleNativeDiagnosticsAuth =
+  | { apiKey: string; clientKey?: never }
+  | { clientKey: string; apiKey?: never };
+
+export type LogBrewAppleNativeDiagnosticsConfiguration =
+  LogBrewAppleNativeDiagnosticsAuth & {
+    projectId: string;
+    release: string;
+    environment: string;
+    service: string;
+    /** Explicitly confirms LogBrew is the process's only native fatal-handler owner. */
+    fatalHandlerOwnership: "logbrew";
+    /** Enable app-hang capture with a threshold from 1 through 30 seconds. Omit to disable. */
+    hangThresholdSeconds?: number;
+    /** Event ingestion endpoint. Defaults to the hosted LogBrew endpoint. */
+    endpoint?: string;
+  };
+
+export type LogBrewAppleNativeDiagnosticsStatus = Readonly<{
+  status: "already_installed" | "installed" | "not_installed" | "ready";
+  lifecycle: "failed" | "idle" | "installed" | "replaying" | "stopped" | "unknown";
+  pending: number;
+  acknowledged: number;
+  discarded: number;
+}>;
+
+export type LogBrewAppleNativeDiagnosticsReplayResult = Readonly<{
+  status: "replayed";
+  attempted: number;
+  acknowledged: number;
+  discarded: number;
+  pending: number;
+}>;
+
+export declare function installLogBrewAppleNativeDiagnostics(
+  configuration: LogBrewAppleNativeDiagnosticsConfiguration
+): LogBrewAppleNativeDiagnosticsStatus;
+
+export declare function replayLogBrewAppleNativeDiagnostics(): Promise<
+  LogBrewAppleNativeDiagnosticsReplayResult
+>;
+
+export declare function getLogBrewAppleNativeDiagnosticsStatus():
+  LogBrewAppleNativeDiagnosticsStatus;
+
+declare const defaultExport: {
+  getLogBrewAppleNativeDiagnosticsStatus: typeof getLogBrewAppleNativeDiagnosticsStatus;
+  installLogBrewAppleNativeDiagnostics: typeof installLogBrewAppleNativeDiagnostics;
+  replayLogBrewAppleNativeDiagnostics: typeof replayLogBrewAppleNativeDiagnostics;
+};
+
+export default defaultExport;

package/apple-native-diagnostics.js

@@ -0,0 +1,286 @@
+import { SdkError } from "@logbrew/sdk";
+import { NativeModules, Platform, TurboModuleRegistry } from "react-native";
+
+const INSTALL_STATUSES = new Set(["already_installed", "installed"]);
+const LIFECYCLE_STATUSES = new Set([
+  "failed",
+  "idle",
+  "installed",
+  "replaying",
+  "stopped",
+  "unknown"
+]);
+
+export function installLogBrewAppleNativeDiagnostics(configuration = {}) {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  const payload = normalizeConfiguration(configuration);
+  const result = callNative(nativeModule, "installNativeDiagnostics", payload);
+  return requireStatusResult("install", result, INSTALL_STATUSES);
+}
+
+export async function replayLogBrewAppleNativeDiagnostics() {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  let result;
+  try {
+    result = await callNative(nativeModule, "replayNativeDiagnostics");
+  } catch (error) {
+    if (error instanceof SdkError) {
+      throw error;
+    }
+    throw new SdkError(
+      "native_diagnostics_failed",
+      "LogBrew Apple native diagnostics replay failed"
+    );
+  }
+  return requireReplayResult(result);
+}
+
+export function getLogBrewAppleNativeDiagnosticsStatus() {
+  requireApplePlatform();
+  const nativeModule = requireNativeModule();
+  const result = callNative(nativeModule, "nativeDiagnosticsStatus");
+  return requireStatusResult("status", result, new Set(["not_installed", "ready"]));
+}
+
+function normalizeConfiguration(configuration) {
+  if (!configuration
+    || Array.isArray(configuration)
+    || typeof configuration !== "object") {
+    throw configurationError("configuration must be an object");
+  }
+  const allowedKeys = new Set([
+    "apiKey",
+    "clientKey",
+    "endpoint",
+    "environment",
+    "fatalHandlerOwnership",
+    "hangThresholdSeconds",
+    "projectId",
+    "release",
+    "service"
+  ]);
+  for (const key of Object.keys(configuration)) {
+    if (!allowedKeys.has(key)) {
+      throw configurationError(`configuration contains unsupported key ${JSON.stringify(key)}`);
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(configuration, "apiKey")
+    && Object.prototype.hasOwnProperty.call(configuration, "clientKey")) {
+    throw configurationError("apiKey and clientKey are mutually exclusive");
+  }
+  const authKey = exactString(
+    "apiKey or clientKey",
+    configuration.clientKey ?? configuration.apiKey,
+    4096
+  );
+  const projectId = exactString("projectId", configuration.projectId, 64);
+  if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u.test(projectId)) {
+    throw configurationError("projectId must be a lowercase UUID");
+  }
+  if (configuration.fatalHandlerOwnership !== "logbrew") {
+    throw configurationError(
+      "fatalHandlerOwnership must be the exact string logbrew after confirming no other native fatal handler is installed"
+    );
+  }
+
+  const payload = {
+    apiKey: authKey,
+    environment: exactString("environment", configuration.environment),
+    fatalHandlerOwnership: "logbrew",
+    projectId,
+    release: exactString("release", configuration.release),
+    service: exactString("service", configuration.service)
+  };
+  if (configuration.endpoint !== undefined) {
+    payload.endpoint = exactDeliveryEndpoint(configuration.endpoint);
+  }
+  if (configuration.hangThresholdSeconds !== undefined) {
+    const threshold = configuration.hangThresholdSeconds;
+    if (typeof threshold !== "number"
+      || !Number.isFinite(threshold)
+      || threshold < 1
+      || threshold > 30) {
+      throw configurationError("hangThresholdSeconds must be a finite number from 1 through 30");
+    }
+    payload.hangThresholdSeconds = threshold;
+  }
+  return payload;
+}
+
+function requireApplePlatform() {
+  if (Platform?.OS !== "ios") {
+    throw new SdkError(
+      "unsupported_platform",
+      "LogBrew Apple native diagnostics are available only in an iOS native build"
+    );
+  }
+}
+
+function requireNativeModule() {
+  let nativeModule;
+  try {
+    nativeModule = TurboModuleRegistry?.get?.("LogBrewAppleDiagnostics")
+      ?? NativeModules?.LogBrewAppleDiagnostics;
+  } catch {
+    nativeModule = undefined;
+  }
+  if (!nativeModule) {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      "LogBrew Apple native diagnostics require the AppleDiagnostics CocoaPods subspec; Expo projects can add @logbrew/react-native/expo"
+    );
+  }
+  return nativeModule;
+}
+
+function callNative(nativeModule, method, ...args) {
+  if (typeof nativeModule?.[method] !== "function") {
+    throw new SdkError(
+      "native_diagnostics_unavailable",
+      `linked LogBrew Apple diagnostics do not implement ${method}`
+    );
+  }
+  try {
+    return nativeModule[method](...args);
+  } catch {
+    throw new SdkError(
+      "native_diagnostics_failed",
+      `LogBrew Apple native diagnostics ${method} failed`
+    );
+  }
+}
+
+function requireStatusResult(operation, result, allowedStatuses) {
+  if (isErrorResult(result)) {
+    throw new SdkError(
+      result.code,
+      `LogBrew Apple native diagnostics ${operation} failed with ${result.code}`
+    );
+  }
+  if (!isPlainObject(result)
+    || !allowedStatuses.has(result.status)
+    || !LIFECYCLE_STATUSES.has(result.lifecycle)
+    || !isCount(result.pending)
+    || !isCount(result.acknowledged)
+    || !isCount(result.discarded)) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      `LogBrew Apple native diagnostics ${operation} returned an invalid response`
+    );
+  }
+  return Object.freeze({
+    acknowledged: result.acknowledged,
+    discarded: result.discarded,
+    lifecycle: result.lifecycle,
+    pending: result.pending,
+    status: result.status
+  });
+}
+
+function requireReplayResult(result) {
+  if (isErrorResult(result)) {
+    throw new SdkError(
+      result.code,
+      `LogBrew Apple native diagnostics replay failed with ${result.code}`
+    );
+  }
+  if (!isPlainObject(result)
+    || result.status !== "replayed"
+    || !isCount(result.attempted)
+    || !isCount(result.acknowledged)
+    || !isCount(result.discarded)
+    || !isCount(result.pending)
+    || result.acknowledged + result.discarded > result.attempted) {
+    throw new SdkError(
+      "native_diagnostics_invalid_response",
+      "LogBrew Apple native diagnostics replay returned an invalid response"
+    );
+  }
+  return Object.freeze({
+    acknowledged: result.acknowledged,
+    attempted: result.attempted,
+    discarded: result.discarded,
+    pending: result.pending,
+    status: result.status
+  });
+}
+
+function isErrorResult(result) {
+  return isPlainObject(result)
+    && result.status === "error"
+    && typeof result.code === "string"
+    && /^[a-z0-9_]{1,128}$/u.test(result.code);
+}
+
+function isPlainObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+
+function isCount(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function exactString(name, value, maxBytes = 256) {
+  if (typeof value !== "string"
+    || value.length === 0
+    || value.trim() !== value
+    || hasControlCharacter(value)
+    || utf8Length(value) > maxBytes) {
+    throw configurationError(`${name} must be a non-empty bounded string without surrounding whitespace or control characters`);
+  }
+  return value;
+}
+
+function exactDeliveryEndpoint(value) {
+  const endpoint = exactString("endpoint", value, 2048);
+  let parsed;
+  try {
+    parsed = new URL(endpoint);
+  } catch {
+    throw configurationError("endpoint must be an absolute HTTPS URL");
+  }
+  if (parsed.protocol !== "https:") {
+    throw configurationError("endpoint must use HTTPS");
+  }
+  if (parsed.username
+    || parsed.password
+    || parsed.search
+    || parsed.hash
+    || endpoint !== `${parsed.origin}${parsed.pathname}`) {
+    throw configurationError("endpoint must be a plain HTTPS path without embedded auth, query, or fragment values");
+  }
+  return endpoint;
+}
+
+function hasControlCharacter(value) {
+  for (const scalar of value) {
+    const codePoint = scalar.codePointAt(0);
+    if (codePoint <= 0x1f || codePoint === 0x7f) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function utf8Length(value) {
+  let bytes = 0;
+  for (const scalar of value) {
+    const codePoint = scalar.codePointAt(0);
+    bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+  }
+  return bytes;
+}
+
+function configurationError(message) {
+  return new SdkError("configuration_error", `LogBrew Apple native diagnostics ${message}`);
+}
+
+const logBrewAppleNativeDiagnostics = {
+  getLogBrewAppleNativeDiagnosticsStatus,
+  installLogBrewAppleNativeDiagnostics,
+  replayLogBrewAppleNativeDiagnostics
+};
+
+export default logBrewAppleNativeDiagnostics;

package/expo.cjs

@@ -0,0 +1,46 @@
+const PLUGIN_NAME = "@logbrew/react-native/expo";
+const START_MARKER = "  # @generated by @logbrew/react-native/expo";
+const END_MARKER = "  # @end @logbrew/react-native/expo";
+const POD_BLOCK = [
+  START_MARKER,
+  "  logbrew_react_native_path = File.dirname(`node --print \"require.resolve('@logbrew/react-native')\"`)",
+  "  pod 'LogBrewReactNative/AppleNativeDiagnostics', :path => logbrew_react_native_path",
+  END_MARKER
+].join("\n");
+
+function withLogBrewReactNative(config, options = {}) {
+  const { withPodfile } = require("expo/config-plugins");
+  return withPodfile(config, (podfileConfig) => {
+    podfileConfig.modResults.contents = modifyPodfile(
+      podfileConfig.modResults.contents,
+      options?.appleNativeDiagnostics !== false
+    );
+    return podfileConfig;
+  });
+}
+
+function modifyPodfile(contents, enabled = true) {
+  if (typeof contents !== "string") {
+    throw new TypeError(`${PLUGIN_NAME} expected Podfile text`);
+  }
+  const withoutManagedBlock = contents.replace(
+    new RegExp(`${escapePattern(START_MARKER)}[\\s\\S]*?${escapePattern(END_MARKER)}\\n?`, "gu"),
+    ""
+  );
+  if (!enabled) {
+    return withoutManagedBlock;
+  }
+  const targetPattern = /^(target\s+['"][^'"]+['"]\s+do\s*)$/mu;
+  if (!targetPattern.test(withoutManagedBlock)) {
+    throw new Error(`${PLUGIN_NAME} could not locate an iOS application target in the Podfile`);
+  }
+  return withoutManagedBlock.replace(targetPattern, `$1\n${POD_BLOCK}`);
+}
+
+function escapePattern(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+
+module.exports = withLogBrewReactNative;
+module.exports.modifyPodfile = modifyPodfile;
+module.exports.withLogBrewReactNative = withLogBrewReactNative;

package/expo.d.ts

@@ -0,0 +1,16 @@
+export type LogBrewExpoPluginOptions = {
+  /** Add the opt-in Apple native crash and app-hang CocoaPods subspec. Defaults to true. */
+  appleNativeDiagnostics?: boolean;
+};
+
+export type ExpoConfigLike = Record<string, unknown>;
+export type LogBrewExpoConfigPlugin = (
+  config: ExpoConfigLike,
+  options?: LogBrewExpoPluginOptions
+) => ExpoConfigLike;
+
+export declare const withLogBrewReactNative: LogBrewExpoConfigPlugin;
+export declare function modifyPodfile(contents: string, enabled?: boolean): string;
+
+declare const defaultExport: LogBrewExpoConfigPlugin;
+export default defaultExport;

package/expo.js

@@ -0,0 +1,5 @@
+import plugin from "./expo.cjs";
+
+export const modifyPodfile = plugin.modifyPodfile;
+export const withLogBrewReactNative = plugin.withLogBrewReactNative;
+export default plugin;

package/fatal-replay.cjs

@@ -293,7 +293,11 @@ function fatalStackFrames(error, stackFrame) {
     const frame = stackFrame(line);
     const filename = frame ? normalizedStoredFatalFilename(frame.filename) : undefined;
     if (filename && validFatalFilename(filename)) {
-      frames.push(Object.freeze({ ...frame, filename }));
+      frames.push(Object.freeze({
+        column: frame.column,
+        filename,
+        line: frame.line
+      }));
       if (frames.length === MAX_FATAL_STACK_FRAMES) {
         break;
       }
@@ -304,6 +308,13 @@ function fatalStackFrames(error, stackFrame) {
 
 function fatalEventAttributes(record, eventMessage) {
   return Object.freeze({
+    exception: Object.freeze({
+      type: record.errorName,
+      mechanism: Object.freeze({
+        type: "react_native_error_utils",
+        handled: false
+      })
+    }),
     level: "fatal",
     message: eventMessage,
     metadata: Object.freeze({

package/global-errors.cjs

@@ -196,7 +196,9 @@ function createAutomaticErrorEvent(error) {
   }
   const event = createReactNativeErrorEvent(sanitizedError, {
     id: nextEventId(),
-    includeStack: false
+    handled: false,
+    includeStack: false,
+    mechanism: "react_native_error_utils"
   });
   return {
     ...event,