@logbrew/react-native 0.1.20 → 0.1.22

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/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,10 @@ 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(),
             timestamp: timestamp.normalized,
@@ -32,9 +36,13 @@ 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,
             hangState: nil,
             hangDurationMs: nil,
             source: .engine(reportID: reportID),

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCapture.swift

@@ -109,6 +109,34 @@ 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 {
+        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)
+        }
+    }
+
+    /// Replaces the crash-time breadcrumb snapshot in one bounded write.
+    @nonobjc
+    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() }
         try verifyProcessLocked()
@@ -116,10 +144,7 @@ public final class NativeCrashCapture: NSObject, @unchecked Sendable {
             throw NativeCrashError(.notInstalled)
         }
         try verifyStorageLocked()
-        try driver.setUserInfo(
-            NativeCrashCorrelation.encoded(context),
-            forKey: NativeCrashCorrelation.reportKey,
-        )
+        try driver.setUserInfo(encoded(), forKey: key)
     }
 
     @objc(replayPendingReportsWithHandler:error:)

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashCorrelation.swift

@@ -2,76 +2,207 @@
 // 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
 }
 
+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)
             }
             return value
-        } catch let error as NativeCrashError {
-            throw error
         } catch {
             throw NativeCrashError(.invalidConfiguration)
         }
     }
 
-    static func captured(in rawReport: [String: Any]) -> (TelemetryContext?, NativeCrashCorrelationState) {
-        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 {
+    static func validated(_ object: Any) throws -> NativeCrashDiagnosticSnapshot {
+        try nativeCrashValidated(object, maximumBytes: maximumBytes) { decoded in
+            guard decoded.schemaVersion == 1 else {
                 throw NativeCrashError(.invalidConfiguration)
             }
-            let data = try JSONSerialization.data(withJSONObject: object, options: [.sortedKeys])
-            guard data.count <= maximumBytes 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)
+        }
+    }
+}
+
+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 nativeCrashEncoded(NativeCrashBreadcrumbSnapshot(
+                    breadcrumbs: breadcrumbs,
+                    truncated: wasTruncated,
+                ))
+                if data.count <= maximumBytes, let value = String(data: data, encoding: .utf8) {
+                    return value
+                }
+                breadcrumbs.removeFirst()
+                wasTruncated = true
             }
-            return context
         } catch let error as NativeCrashError {
             throw error
         } catch {
             throw NativeCrashError(.invalidConfiguration)
         }
+        throw NativeCrashError(.invalidConfiguration)
+    }
+
+    static func captured(
+        in rawReport: [String: Any],
+    ) -> (NativeCrashBreadcrumbSnapshot?, NativeCrashContextState) {
+        nativeCrashCaptured(in: rawReport, key: reportKey, maximumBytes: maximumBytes, validate: validated)
     }
 
-    private static func encoder() -> JSONEncoder {
-        let encoder = JSONEncoder()
-        encoder.outputFormatting = [.sortedKeys, .withoutEscapingSlashes]
-        return encoder
+    static func validated(_ object: Any) throws -> NativeCrashBreadcrumbSnapshot {
+        try nativeCrashValidated(object, maximumBytes: maximumBytes) { decoded in
+            guard decoded.schemaVersion == 1,
+                  !decoded.breadcrumbs.isEmpty,
+                  decoded.breadcrumbs.count <= maximumIssueBreadcrumbs
+            else {
+                throw NativeCrashError(.invalidConfiguration)
+            }
+            return try NativeCrashBreadcrumbSnapshot(
+                breadcrumbs: decoded.breadcrumbs.map(validateIssueBreadcrumb),
+                truncated: decoded.truncated,
+            )
+        }
     }
 }
+
+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

@@ -164,7 +164,11 @@ 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 impact: IssueImpactEvidence?
+    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 +182,11 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         nativeStackFrames: [NativeStackFrame]?,
         artifactIdentity: NativeArtifactIdentity?,
         context: TelemetryContext?,
-        correlationState: NativeCrashCorrelationState? = nil,
+        correlationState: NativeCrashContextState? = nil,
+        impact: IssueImpactEvidence? = nil,
+        breadcrumbs: [IssueBreadcrumb]? = nil,
+        breadcrumbsTruncated: Bool? = nil,
+        breadcrumbState: NativeCrashContextState? = nil,
         hangState: NativeHangIncidentState?,
         hangDurationMs: Double? = nil,
         source: NativeCrashRecordSource,
@@ -192,6 +200,10 @@ 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
         self.hangState = hangState
         self.hangDurationMs = hangDurationMs
         self.source = source
@@ -234,6 +246,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 +260,9 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
             level: hangState == .recovered ? .error : .fatal,
             exception: issueException,
             exceptionChain: nativeCrashExceptionChain(for: issueException),
+            breadcrumbs: breadcrumbs,
+            breadcrumbsTruncated: breadcrumbsTruncated,
+            evidence: impact.map { IssueDiagnosticEvidence(impact: $0) },
             metadata: metadata,
             context: context,
             nativeStackFrames: nativeStackFrames,
@@ -287,12 +305,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", "evidence", "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

@@ -10,8 +10,8 @@
     "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/IssueDiagnostics.swift": "297b8bbefd42c314a984fecb38237fb1395700c9eafcfdd1b545267bc34294cc",
+    "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",
     "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": "a56a2f6c6c7f1db900804a37df51aebba7b83dce14fa7816de5753c33409e4a5",
     "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": "0b773a63987b6c694b044e56c0f81878f4f5e71eae3fdd126744cba3cf15aac1",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCorrelation.swift": "e5a7c25448c83ca2ae149c650ecfc72c5193741291a6ff9623eabadad8a9c440",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashExceptionEvidence.swift": "ce191e46298d91d87b379528d610caa88b924b15a8dd912b4a164b51eb172a7a",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "1672116a06fbdd10971838817591ee23af68bd5a9b07bbffb073e0fafc6cb1c0",
+    "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;