@logbrew/react-native 0.1.21 → 0.1.23

package/LogBrewReactNative.podspec

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

package/README.md

@@ -327,7 +327,11 @@ setLogBrewAppleNativeCrashContext({
   schemaVersion: 1,
   trace: { traceId: trace.traceId, spanId: trace.spanId, sampled: trace.sampled },
   session: { id: "session_123" },
-  subject: { id: "subject_456", kind: "user" }
+  subject: { id: "subject_456", kind: "user" },
+  impact: {
+    failedAction: "checkout.submit",
+    userVisibleOutcome: "The order was not confirmed."
+  }
 });
 
 void replayLogBrewAppleNativeDiagnostics().catch((error) => {
@@ -342,10 +346,15 @@ allowed, but only one integration may install native fatal capture in a given
 process. LogBrew cannot transfer or remove that ownership before process
 restart.
 
-Update this snapshot when the active trace, session, or subject changes, and
+Update this snapshot when the active trace, session, subject, or failed action changes, and
 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.
+later app launch cannot replace it. `impact` is explicit app knowledge. Use a
+stable action name and an optional safe user-visible result. Never include raw
+input, request data, authentication values, or identity. Session and subject values must
+be opaque app-owned identifiers made from ASCII letters, numbers, `_`, or `-`.
+Resource context, tags, arbitrary fields, and values over the fixed 4 KiB
+snapshot limit fail before storage.
 
 The iOS `createLogBrewReactNativeClient()` entry also mirrors its validated
 breadcrumb history into native crash capture. Install Apple diagnostics first,
@@ -579,11 +588,17 @@ export function App({ client }) {
 
 Screen views carry the versioned `screen_view` analytics classification, and explicit product actions carry `interaction`. The SDK uses the app-owned screen name as a bounded surface and does not inspect view hierarchies, selectors, or input values. Caller metadata cannot replace the reserved classification. See the repository [product analytics capture contract](../../docs/product-analytics-contract.md).
 
-The package ships a `react-native` entry that imports `AppState` and `Platform` for Metro, while the default Node entry accepts those dependencies explicitly. That keeps mobile setup explicit instead of pretending a Node process is a native runtime.
+The package ships a `react-native` entry that binds platform state and linked native services for Metro, while the default server entry accepts runtime dependencies explicitly. That keeps mobile setup explicit without treating a server process as a native runtime.
 
 ## Trace Propagation
 
-Use an active trace when one product operation should connect screen views, logs, handled errors, actions, network milestones, explicit spans, and outbound request headers. `createReactNativeTraceContext()` continues a valid W3C `traceparent` with a fresh local span ID and falls back to a local root when the incoming value is missing or malformed:
+Use an active trace when one product operation should connect screen views, logs, handled errors, actions, network milestones, explicit spans, and outbound request headers. `createReactNativeTraceContext()` continues a valid W3C `traceparent` with a fresh local span ID and falls back to a local root when the incoming value is missing or malformed.
+
+The React Native entry creates trace and span IDs with the linked platform's
+cryptographic random source, or Expo Crypto in a managed runtime. It fails
+closed when neither source exists and never falls back to `Math.random` or
+predictable bytes. Callers may still inject `randomValues` when deterministic
+input control is required.
 
 ```js
 import {

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

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

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

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

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

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

package/apple-native-diagnostics.d.ts

@@ -36,6 +36,11 @@ export type LogBrewAppleNativeDiagnosticsReplayResult = Readonly<{
 
 export type LogBrewAppleNativeCrashContext = {
   schemaVersion: 1;
+  /** App-reported failed action and optional user-visible result. Never include raw input or identity. */
+  impact?: {
+    failedAction: string;
+    userVisibleOutcome?: string;
+  };
   trace?: TelemetryTraceContext;
   session?: TelemetrySessionContext;
   subject?: TelemetrySubjectContext;

package/apple-native-diagnostics.js

@@ -144,7 +144,11 @@ function normalizeConfiguration(configuration) {
 }
 
 function normalizeCorrelationContext(context) {
-  const source = exactObject(context, ["schemaVersion", "session", "subject", "trace"], "context");
+  const source = exactObject(
+    context,
+    ["impact", "schemaVersion", "session", "subject", "trace"],
+    "context"
+  );
   if (source.schemaVersion !== 1) {
     throw configurationError("context schemaVersion must be 1");
   }
@@ -185,8 +189,26 @@ function normalizeCorrelationContext(context) {
     }
     output.subject = { id: opaqueCorrelationId(subject.id, "subject id"), kind: subject.kind };
   }
+  if (source.impact !== undefined) {
+    const impact = exactObject(
+      source.impact,
+      ["failedAction", "userVisibleOutcome"],
+      "context impact"
+    );
+    output.impact = {
+      failedAction: diagnosticText(impact.failedAction, 256, true, "failedAction")
+    };
+    if (impact.userVisibleOutcome !== undefined) {
+      output.impact.userVisibleOutcome = diagnosticText(
+        impact.userVisibleOutcome,
+        512,
+        false,
+        "userVisibleOutcome"
+      );
+    }
+  }
   if (Object.keys(output).length === 1) {
-    throw configurationError("context must include trace, session, or subject");
+    throw configurationError("context must include trace, session, subject, or impact");
   }
   return output;
 }
@@ -218,6 +240,17 @@ function opaqueCorrelationId(value, name) {
   return value;
 }
 
+function diagnosticText(value, maximum, rejectLocationText, name) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (normalized.length === 0
+    || Array.from(normalized).length > maximum
+    || hasControlCharacter(normalized)
+    || (rejectLocationText && /[?#]/u.test(normalized))) {
+    throw configurationError(`context impact ${name} is invalid`);
+  }
+  return normalized;
+}
+
 function requireApplePlatform() {
   if (Platform?.OS !== "ios") {
     throw new SdkError(
@@ -366,7 +399,7 @@ function exactDeliveryEndpoint(value) {
 function hasControlCharacter(value) {
   for (const scalar of value) {
     const codePoint = scalar.codePointAt(0);
-    if (codePoint <= 0x1f || codePoint === 0x7f) {
+    if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f)) {
       return true;
     }
   }

package/index.cjs

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

package/index.native.js

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

package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift

@@ -3,7 +3,7 @@ import Foundation
 @objc(LBRNAppleNativeDiagnostics)
 public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
     private static let shared = LBRNAppleNativeDiagnostics()
-    private static let sdkVersion = "0.1.21"
+    private static let sdkVersion = "0.1.23"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")
@@ -149,8 +149,11 @@ public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
             return failure("native_diagnostics_not_installed")
         }
         do {
-            let context = try rawContext.map { try NativeCrashCorrelation.validated($0) }
-            try capture.setCorrelationContext(context)
+            let snapshot = try rawContext.map { try NativeCrashCorrelation.validated($0) }
+            try capture.setDiagnosticContext(
+                context: snapshot?.correlationContext,
+                impact: snapshot?.impact,
+            )
             return ["status": rawContext == nil ? "cleared" : "updated"]
         } catch let error as NativeCrashError {
             return failure(error.code.rawValue)

package/ios/GeneratedAppleDiagnostics/LogBrew/IssueDiagnosticEvidence.swift

@@ -77,7 +77,8 @@ public struct IssueDiagnosticEvidence: Codable, Equatable, Sendable {
     }
 }
 
-func validateIssueDiagnosticEvidence(_ value: IssueDiagnosticEvidence) throws -> IssueDiagnosticEvidence {
+@_spi(CrashReplay)
+public func validateIssueDiagnosticEvidence(_ value: IssueDiagnosticEvidence) throws -> IssueDiagnosticEvidence {
     let cause = try value.likelyRootCause.map {
         try issueText($0, label: "issue evidence likelyRootCause", maximum: 1024)
     }

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/CrashReportSanitizer.swift

@@ -23,6 +23,9 @@ struct CrashReportSanitizer {
         let nativeStackFrames = NativeStackFrameSanitizer().frames(from: rawReport)
         let artifactIdentity = try NativeArtifactIdentityValue.persistedIdentity(in: rawReport)
         let correlation = NativeCrashCorrelation.captured(in: rawReport)
+        let correlationState = correlation.0?.correlationContext == nil && correlation.1 == .captured
+            ? NativeCrashContextState.notCaptured
+            : correlation.1
         let breadcrumbs = NativeCrashBreadcrumbs.captured(in: rawReport)
         return NativeCrashRecord(
             eventID: uuid.uuidString.lowercased(),
@@ -33,9 +36,10 @@ struct CrashReportSanitizer {
             context: nativeCrashContext(
                 system: rawReport["system"] as? [String: Any],
                 artifactIdentity: artifactIdentity,
-                correlation: correlation.0,
+                correlation: correlation.0?.correlationContext,
             ),
-            correlationState: correlation.1,
+            correlationState: correlationState,
+            impact: correlation.0?.impact,
             breadcrumbs: breadcrumbs.0?.breadcrumbs,
             breadcrumbsTruncated: breadcrumbs.0?.truncated,
             breadcrumbState: breadcrumbs.1,

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCapture.swift

@@ -109,17 +109,17 @@ public final class NativeCrashCapture: NSObject, @unchecked Sendable {
     /// Replaces the crash-time trace, session, and opaque subject snapshot in one bounded write.
     @nonobjc
     public func setCorrelationContext(_ context: TelemetryContext?) throws {
-        lock.lock()
-        defer { lock.unlock() }
-        try verifyProcessLocked()
-        guard store != nil, lifecycle != .stopped else {
-            throw NativeCrashError(.notInstalled)
+        try setDiagnosticContext(context: context, impact: nil)
+    }
+
+    @nonobjc
+    func setDiagnosticContext(
+        context: TelemetryContext?,
+        impact: IssueImpactEvidence?,
+    ) throws {
+        try setSnapshot(forKey: NativeCrashCorrelation.reportKey) {
+            try NativeCrashCorrelation.encoded(context: context, impact: impact)
         }
-        try verifyStorageLocked()
-        try driver.setUserInfo(
-            NativeCrashCorrelation.encoded(context),
-            forKey: NativeCrashCorrelation.reportKey,
-        )
     }
 
     /// Replaces the crash-time breadcrumb snapshot in one bounded write.
@@ -127,6 +127,15 @@ public final class NativeCrashCapture: NSObject, @unchecked Sendable {
     public func setBreadcrumbs(
         _ breadcrumbs: [IssueBreadcrumb]?,
         truncated: Bool = false,
+    ) throws {
+        try setSnapshot(forKey: NativeCrashBreadcrumbs.reportKey) {
+            try NativeCrashBreadcrumbs.encoded(breadcrumbs, truncated: truncated)
+        }
+    }
+
+    private func setSnapshot(
+        forKey key: String,
+        encoded: () throws -> String?,
     ) throws {
         lock.lock()
         defer { lock.unlock() }
@@ -135,10 +144,7 @@ public final class NativeCrashCapture: NSObject, @unchecked Sendable {
             throw NativeCrashError(.notInstalled)
         }
         try verifyStorageLocked()
-        try driver.setUserInfo(
-            NativeCrashBreadcrumbs.encoded(breadcrumbs, truncated: truncated),
-            forKey: NativeCrashBreadcrumbs.reportKey,
-        )
+        try driver.setUserInfo(encoded(), forKey: key)
     }
 
     @objc(replayPendingReportsWithHandler:error:)

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCorrelation.swift

@@ -8,16 +8,60 @@ enum NativeCrashContextState: String {
     case unavailable
 }
 
+struct NativeCrashDiagnosticSnapshot: Codable, Equatable {
+    let schemaVersion: Int
+    let trace: TelemetryTraceContext?
+    let session: TelemetrySessionContext?
+    let subject: TelemetrySubjectContext?
+    let impact: IssueImpactEvidence?
+
+    init(context: TelemetryContext?, impact: IssueImpactEvidence?) throws {
+        let context = try context.map(validateNativeCrashCorrelationContext)
+        let impact = try impact.map { value in
+            guard value.affectedUserSegment == nil,
+                  let value = try validateIssueDiagnosticEvidence(
+                      IssueDiagnosticEvidence(impact: value),
+                  ).impact,
+                  value.failedAction != nil
+            else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            return value
+        }
+        guard context != nil || impact != nil else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        schemaVersion = 1
+        trace = context?.trace
+        session = context?.session
+        subject = context?.subject
+        self.impact = impact
+    }
+
+    var correlationContext: TelemetryContext? {
+        trace == nil && session == nil && subject == nil
+            ? nil
+            : TelemetryContext(trace: trace, session: session, subject: subject)
+    }
+
+}
+
 enum NativeCrashCorrelation {
     static let reportKey = "logbrew_native_correlation"
-    private static let maximumBytes = 1024
+    private static let maximumBytes = 4 * 1024
 
-    static func encoded(_ context: TelemetryContext?) throws -> String? {
-        guard let context else {
+    static func encoded(
+        context: TelemetryContext?,
+        impact: IssueImpactEvidence? = nil,
+    ) throws -> String? {
+        guard context != nil || impact != nil else {
             return nil
         }
         do {
-            let data = try encoder().encode(validateNativeCrashCorrelationContext(context))
+            let data = try nativeCrashEncoded(NativeCrashDiagnosticSnapshot(
+                context: context,
+                impact: impact,
+            ))
             guard data.count <= maximumBytes, let value = String(data: data, encoding: .utf8) else {
                 throw NativeCrashError(.invalidConfiguration)
             }
@@ -27,51 +71,23 @@ enum NativeCrashCorrelation {
         }
     }
 
-    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)
-        }
-        guard let value = value as? String,
-              let data = value.data(using: .utf8),
-              data.count <= maximumBytes,
-              let object = try? JSONSerialization.jsonObject(with: data),
-              let context = try? validated(object)
-        else {
-            return (nil, .unavailable)
-        }
-        return (context, .captured)
+    static func captured(
+        in rawReport: [String: Any],
+    ) -> (NativeCrashDiagnosticSnapshot?, NativeCrashContextState) {
+        nativeCrashCaptured(in: rawReport, key: reportKey, maximumBytes: maximumBytes, validate: validated)
     }
 
-    static func validated(_ object: Any) throws -> TelemetryContext {
-        do {
-            guard JSONSerialization.isValidJSONObject(object) else {
-                throw NativeCrashError(.invalidConfiguration)
-            }
-            let data = try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
-            guard data.count <= maximumBytes else {
+    static func validated(_ object: Any) throws -> NativeCrashDiagnosticSnapshot {
+        try nativeCrashValidated(object, maximumBytes: maximumBytes) { decoded in
+            guard decoded.schemaVersion == 1 else {
                 throw NativeCrashError(.invalidConfiguration)
             }
-            let context = try validateNativeCrashCorrelationContext(
-                JSONDecoder().decode(TelemetryContext.self, from: data),
+            return try NativeCrashDiagnosticSnapshot(
+                context: decoded.correlationContext,
+                impact: decoded.impact,
             )
-            let normalized = try encoder().encode(context)
-            let normalizedObject = try JSONSerialization.jsonObject(with: normalized)
-            guard object as? NSDictionary == normalizedObject as? NSDictionary else {
-                throw NativeCrashError(.invalidConfiguration)
-            }
-            return context
-        } 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
-    }
 }
 
 struct NativeCrashBreadcrumbSnapshot: Codable, Equatable {
@@ -98,7 +114,7 @@ enum NativeCrashBreadcrumbs {
             var breadcrumbs = try values.suffix(maximumIssueBreadcrumbs).map(validateIssueBreadcrumb)
             var wasTruncated = truncated || breadcrumbs.count < values.count
             while !breadcrumbs.isEmpty {
-                let data = try encoder().encode(NativeCrashBreadcrumbSnapshot(
+                let data = try nativeCrashEncoded(NativeCrashBreadcrumbSnapshot(
                     breadcrumbs: breadcrumbs,
                     truncated: wasTruncated,
                 ))
@@ -119,56 +135,74 @@ enum NativeCrashBreadcrumbs {
     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)
+        nativeCrashCaptured(in: rawReport, key: reportKey, maximumBytes: maximumBytes, validate: validated)
     }
 
     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)
+        try nativeCrashValidated(object, maximumBytes: maximumBytes) { decoded in
             guard decoded.schemaVersion == 1,
                   !decoded.breadcrumbs.isEmpty,
                   decoded.breadcrumbs.count <= maximumIssueBreadcrumbs
             else {
                 throw NativeCrashError(.invalidConfiguration)
             }
-            let snapshot = try NativeCrashBreadcrumbSnapshot(
+            return 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
+private func nativeCrashCaptured<Value>(
+    in rawReport: [String: Any],
+    key: String,
+    maximumBytes: Int,
+    validate: (Any) throws -> Value,
+) -> (Value?, NativeCrashContextState) {
+    guard let user = rawReport["user"] as? [String: Any], let rawValue = user[key] else {
+        return (nil, .notCaptured)
+    }
+    guard let value = rawValue as? String,
+          let data = value.data(using: .utf8),
+          data.count <= maximumBytes,
+          let object = try? JSONSerialization.jsonObject(with: data),
+          let snapshot = try? validate(object)
+    else {
+        return (nil, .unavailable)
+    }
+    return (snapshot, .captured)
+}
+
+private func nativeCrashValidated<Value: Codable>(
+    _ object: Any,
+    maximumBytes: Int,
+    normalize: (Value) throws -> Value,
+) throws -> Value {
+    do {
+        guard JSONSerialization.isValidJSONObject(object) else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        let source = try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
+        guard source.count <= maximumBytes else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        let value = try normalize(JSONDecoder().decode(Value.self, from: source))
+        let normalized = try nativeCrashEncoded(value)
+        let normalizedObject = try JSONSerialization.jsonObject(with: normalized)
+        guard object as? NSDictionary == normalizedObject as? NSDictionary else {
+            throw NativeCrashError(.invalidConfiguration)
+        }
+        return value
+    } catch let error as NativeCrashError {
+        throw error
+    } catch {
+        throw NativeCrashError(.invalidConfiguration)
     }
 }
+
+private func nativeCrashEncoded(_ value: some Encodable) throws -> Data {
+    let encoder = JSONEncoder()
+    encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
+    return try encoder.encode(value)
+}