@logbrew/react-native 0.1.21 → 0.1.22

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,

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

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.22"
 
     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)
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashPublic.swift

@@ -165,6 +165,7 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
     private let artifactIdentity: NativeArtifactIdentity?
     private let context: TelemetryContext?
     private let correlationState: NativeCrashContextState?
+    private let impact: IssueImpactEvidence?
     private let breadcrumbs: [IssueBreadcrumb]?
     private let breadcrumbsTruncated: Bool?
     private let breadcrumbState: NativeCrashContextState?
@@ -182,6 +183,7 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         artifactIdentity: NativeArtifactIdentity?,
         context: TelemetryContext?,
         correlationState: NativeCrashContextState? = nil,
+        impact: IssueImpactEvidence? = nil,
         breadcrumbs: [IssueBreadcrumb]? = nil,
         breadcrumbsTruncated: Bool? = nil,
         breadcrumbState: NativeCrashContextState? = nil,
@@ -198,6 +200,7 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         self.artifactIdentity = artifactIdentity
         self.context = context
         self.correlationState = correlationState
+        self.impact = impact
         self.breadcrumbs = breadcrumbs
         self.breadcrumbsTruncated = breadcrumbsTruncated
         self.breadcrumbState = breadcrumbState
@@ -259,6 +262,7 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
             exceptionChain: nativeCrashExceptionChain(for: issueException),
             breadcrumbs: breadcrumbs,
             breadcrumbsTruncated: breadcrumbsTruncated,
+            evidence: impact.map { IssueDiagnosticEvidence(impact: $0) },
             metadata: metadata,
             context: context,
             nativeStackFrames: nativeStackFrames,
@@ -301,7 +305,7 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         else {
             return false
         }
-        let legacyFields = ["exception", "exceptionChain", "breadcrumbs", "breadcrumbsTruncated", "context"]
+        let legacyFields = ["exception", "exceptionChain", "evidence", "breadcrumbs", "breadcrumbsTruncated", "context"]
         for legacyField in legacyFields where actual[legacyField] == nil {
             expected.removeValue(forKey: legacyField)
         }

package/ios/GeneratedAppleDiagnostics/SOURCE-MANIFEST.json

@@ -10,7 +10,7 @@
     "swift/logbrew-swift/Sources/LogBrew/DurableDeliveryStore.swift": "7c292dda68efc3de790daf44733b25e4392226793343c21ba5df4f51fc1b402b",
     "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/IssueDiagnosticEvidence.swift": "1042b5a6283cf440529572844e5ad1f3078f4ba715133932ea305e075614a53c",
     "swift/logbrew-swift/Sources/LogBrew/IssueDiagnostics.swift": "bbdfe6169961ff27b8f2cee63c7dcdeacf2e5cee6a3ca17f6a26b933f0adfc39",
     "swift/logbrew-swift/Sources/LogBrew/IssueExceptionChain.swift": "10f81cbce95b47da0a44ef9e515b150e60d71dfcc8b04be24b037b1222a373a5",
     "swift/logbrew-swift/Sources/LogBrew/LifecycleTrace.swift": "738cd3f129fac821a892404d1d42ee92bd806b6583d3dbb5379e88b14ab23c16",
@@ -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": "ccd0ef83f14096816765278e007f5e4ba0a40286ce00d708b38ca0b94959171e",
+    "swift/logbrew-swift/Sources/LogBrewCrash/CrashReportSanitizer.swift": "a56a2f6c6c7f1db900804a37df51aebba7b83dce14fa7816de5753c33409e4a5",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashStorageDirectory.swift": "7cd566703cbf704dc99155451ee93dcace12c35c805abc09a6dcf23975cf43f9",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeArtifactIdentity.swift": "3d785ad717dcf7302451531c18b5e1183983270a6cd78dd543a407e3facc6ae0",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCapture.swift": "c2f5d0e9a8953cb988633ebf60a06f3b7ddaa0c9828f99372969fdfb60b99bc4",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCorrelation.swift": "eef19c6e561bc03bb4c09736722afe57f63d557f9279b26353679bd53362c25d",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCapture.swift": "0b773a63987b6c694b044e56c0f81878f4f5e71eae3fdd126744cba3cf15aac1",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCorrelation.swift": "e5a7c25448c83ca2ae149c650ecfc72c5193741291a6ff9623eabadad8a9c440",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashExceptionEvidence.swift": "ce191e46298d91d87b379528d610caa88b924b15a8dd912b4a164b51eb172a7a",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "2d0f2e7cdce09dc09906cede5d83928e8bd0e70a8522ff55c999d19366d84730",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "70aa9700efd26d03b9656f1df96876de0b9eb769c03512ec53f667696773954f",
     "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/lifecycle.js

@@ -1,121 +1,7 @@
-import { SdkError } from "@logbrew/sdk";
-import {
-  createReactNativeSpanAttributes,
-  createReactNativeTraceContext,
-  getActiveLogBrewTrace,
-  getReactNativeContext
-} from "./index.js";
+import runtime from "./lifecycle.cjs";
 
-export function createReactNativeLifecycleSpanEvent({
-  durationMs, fromState, id, idFactory = defaultLifecycleSpanEventId, metadata = {}, name,
-  now = () => new Date().toISOString(), platform, appState, screen, sessionId, state, status = "ok",
-  timestamp, toState, trace
-} = {}) {
-  const safeFromState = normalizeLifecycleState(fromState);
-  const safeToState = normalizeLifecycleState(toState ?? state);
-  const transition = [safeFromState, safeToState].filter(Boolean).join("->");
-  const spanName = name ?? `app_state:${transition || safeToState || safeFromState || "change"}`;
-  const activeTrace = trace ?? getActiveLogBrewTrace() ?? createReactNativeTraceContext();
-  return {
-    id: id ?? idFactory({ fromState: safeFromState, screen, toState: safeToState }),
-    timestamp: timestamp ?? now(),
-    attributes: createReactNativeSpanAttributes({
-      name: spanName,
-      status,
-      durationMs,
-      trace: activeTrace,
-      metadata: {
-        ...getReactNativeContext({ platform, appState }),
-        source: "react-native.lifecycle",
-        appState: safeToState,
-        durationMs,
-        fromAppState: safeFromState,
-        screen,
-        sessionId,
-        toAppState: safeToState,
-        ...metadata
-      }
-    })
-  };
-}
-
-export function captureReactNativeLifecycleSpan(client, input = {}) {
-  requireClient(client);
-  const event = createReactNativeLifecycleSpanEvent(input);
-  client.span(event.id, event.timestamp, event.attributes);
-  return event;
-}
-
-export function createAppStateLifecycleSpanListener(client, appState, {
-  captureInitialState = false, metadata = {}, now = () => new Date().toISOString(), nowMs = () => Date.now(),
-  onError, platform, screen, sessionId, trace
-} = {}) {
-  requireClient(client);
-  if (!appState || typeof appState.addEventListener !== "function") {
-    throw new SdkError("configuration_error", "createAppStateLifecycleSpanListener requires AppState.addEventListener");
-  }
-
-  let previousState = normalizeLifecycleState(appState.currentState);
-  let previousChangedAtMs = nowMs();
-  if (captureInitialState && previousState !== undefined) {
-    captureReactNativeLifecycleSpan(client, {
-      appState, metadata, now, platform, screen, sessionId, toState: previousState, trace
-    });
-  }
-
-  const subscription = appState.addEventListener("change", (nextState) => {
-    try {
-      const safeNextState = normalizeLifecycleState(nextState);
-      if (safeNextState === undefined) {
-        return;
-      }
-      const changedAtMs = nowMs();
-      const durationMs = previousState === undefined ? undefined : Math.max(0, changedAtMs - previousChangedAtMs);
-      captureReactNativeLifecycleSpan(client, {
-        appState, durationMs, fromState: previousState, metadata, now, platform, screen, sessionId,
-        timestamp: now(), toState: safeNextState, trace
-      });
-      previousState = safeNextState;
-      previousChangedAtMs = changedAtMs;
-    } catch (error) {
-      if (typeof onError === "function") {
-        onError(error);
-      } else {
-        throw error;
-      }
-    }
-  });
-
-  return subscriptionRemover(subscription);
-}
-
-function requireClient(client) {
-  if (!client) {
-    throw new SdkError("configuration_error", "LogBrew React Native lifecycle helpers require a client");
-  }
-}
-
-function defaultLifecycleSpanEventId({ fromState, screen, toState }) {
-  return `evt_native_lifecycle_${slugify([screen, fromState, toState].filter(Boolean).join("_") || "app_state")}`;
-}
-
-function normalizeLifecycleState(state) {
-  return typeof state === "string" && state.trim() !== "" ? state.trim() : undefined;
-}
-
-function subscriptionRemover(subscription) {
-  if (typeof subscription === "function") {
-    return subscription;
-  }
-  if (subscription && typeof subscription.remove === "function") {
-    return () => subscription.remove();
-  }
-  return () => {};
-}
-
-function slugify(value) {
-  return String(value)
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "") || "event";
-}
+export const {
+  captureReactNativeLifecycleSpan,
+  createAppStateLifecycleSpanListener,
+  createReactNativeLifecycleSpanEvent
+} = runtime;

package/native-bridge.js

@@ -1,125 +1,10 @@
-import { SdkError } from "@logbrew/sdk";
-import {
-  getActiveLogBrewTrace,
-  getReactNativeTraceMetadata
-} from "./index.js";
+import runtime from "./native-bridge.cjs";
 
-const DEFAULT_SCOPE_SOURCE = "react-native.native_bridge";
-const RESERVED_TRACE_METADATA_KEYS = new Set([
-  "parentSpanId",
-  "spanId",
-  "traceFlags",
-  "traceId",
-  "traceSampled",
-  "traceparent"
-]);
-
-export function createLogBrewNativeBridgeScope({
-  logger,
-  metadata = {},
-  screen,
-  sessionId,
-  source = DEFAULT_SCOPE_SOURCE,
-  trace = getActiveLogBrewTrace()
-} = {}) {
-  const traceMetadata = getReactNativeTraceMetadata(trace);
-  return {
-    trace: Object.keys(traceMetadata).length === 0 ? undefined : {
-      parentSpanId: traceMetadata.parentSpanId,
-      spanId: traceMetadata.spanId,
-      traceFlags: traceMetadata.traceFlags,
-      traceId: traceMetadata.traceId,
-      traceSampled: traceMetadata.traceSampled
-    },
-    metadata: compactMetadata({
-      ...metadata,
-      logger,
-      screen,
-      sessionId,
-      source
-    })
-  };
-}
-
-export function syncLogBrewNativeBridgeScope(nativeBridge, options = {}) {
-  const payload = createLogBrewNativeBridgeScope(options);
-  bridgeSync(nativeBridge)(payload);
-  return payload;
-}
-
-export function clearLogBrewNativeBridgeScope(nativeBridge) {
-  bridgeClear(nativeBridge)();
-}
-
-export function withLogBrewNativeBridgeScope(nativeBridge, options, callback) {
-  const resolvedOptions = typeof options === "function" ? {} : options ?? {};
-  const resolvedCallback = typeof options === "function" ? options : callback;
-  if (typeof resolvedCallback !== "function") {
-    throw new SdkError("configuration_error", "withLogBrewNativeBridgeScope requires a callback");
-  }
-
-  const payload = syncLogBrewNativeBridgeScope(nativeBridge, resolvedOptions);
-  try {
-    const result = resolvedCallback(payload);
-    if (result && typeof result.then === "function") {
-      return Promise.resolve(result).finally(() => clearLogBrewNativeBridgeScope(nativeBridge));
-    }
-    clearLogBrewNativeBridgeScope(nativeBridge);
-    return result;
-  } catch (error) {
-    clearLogBrewNativeBridgeScope(nativeBridge);
-    throw error;
-  }
-}
-
-function bridgeSync(nativeBridge) {
-  if (typeof nativeBridge === "function") {
-    return nativeBridge;
-  }
-  if (nativeBridge && typeof nativeBridge.setLogBrewScope === "function") {
-    return nativeBridge.setLogBrewScope.bind(nativeBridge);
-  }
-  if (nativeBridge && typeof nativeBridge.syncLogBrewScope === "function") {
-    return nativeBridge.syncLogBrewScope.bind(nativeBridge);
-  }
-  throw new SdkError(
-    "configuration_error",
-    "LogBrew native bridge scope sync requires a function, setLogBrewScope, or syncLogBrewScope"
-  );
-}
-
-function bridgeClear(nativeBridge) {
-  if (nativeBridge && typeof nativeBridge.clearLogBrewScope === "function") {
-    return nativeBridge.clearLogBrewScope.bind(nativeBridge);
-  }
-  if (nativeBridge && typeof nativeBridge.clearLogBrewTraceContext === "function") {
-    return nativeBridge.clearLogBrewTraceContext.bind(nativeBridge);
-  }
-  if (typeof nativeBridge === "function") {
-    return () => nativeBridge(undefined);
-  }
-  return () => {};
-}
-
-function compactMetadata(metadata) {
-  const compacted = {};
-  for (const [key, value] of Object.entries(metadata)) {
-    if (value === undefined) {
-      continue;
-    }
-    if (RESERVED_TRACE_METADATA_KEYS.has(key)) {
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-      compacted[key] = value;
-    }
-  }
-  return compacted;
-}
-
-export default {
+export const {
   clearLogBrewNativeBridgeScope,
   createLogBrewNativeBridgeScope,
   syncLogBrewNativeBridgeScope,
   withLogBrewNativeBridgeScope
-};
+} = runtime;
+
+export default runtime.default;

package/package.json

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