@crumbsdk/react-native 0.0.1-rc.3 → 0.0.1-rc.4

package/native/ios/packages/ios/Sources/CrumbCore/CrumbJavaScriptFailureContext.swift

@@ -0,0 +1,166 @@
+import Foundation
+#if canImport(Darwin)
+import Darwin
+#endif
+#if canImport(Network)
+import Network
+#endif
+
+/// Local persistence only. Native stack evidence uses envelope 1.1.
+package struct CrumbJavaScriptFailureContext: Codable, Equatable, Sendable {
+    package var screenContext: CrumbScreenContext? = nil
+    package var rendering: CrumbRenderingSnapshot? = nil
+    package var stacks: CrumbFailureStacks? = nil
+    package let capturedAt: Date
+    package let processName: String
+    package let processID: Int32
+    package let cpuUsagePercent: Double?
+    package let residentMemoryBytes: UInt64?
+    package let physicalFootprintBytes: UInt64?
+    package let threadCount: Int?
+    package let thermalState: String
+    package let networkStatus: String
+    package let networkTransport: String
+    package let networkExpensive: Bool
+    package let networkConstrained: Bool
+
+    package func validated() -> Self? {
+        guard capturedAt.timeIntervalSince1970.isFinite,
+              capturedAt.timeIntervalSince1970 > 0, processID > 0,
+              !processName.isEmpty, processName.utf8.count <= 128,
+              cpuUsagePercent.map({ $0.isFinite && $0 >= 0 && $0 <= 100_000 }) ?? true,
+              threadCount.map({ $0 >= 0 && $0 <= 10_000 }) ?? true,
+              ["nominal", "fair", "serious", "critical", "unknown", "unavailable"].contains(thermalState),
+              ["reachable", "unreachable", "unknown"].contains(networkStatus),
+              ["wifi", "cellular", "ethernet", "other", "none", "unknown"].contains(networkTransport)
+        else { return nil }
+        var result = self
+        result.stacks = stacks?.validated()
+        result.rendering = rendering?.validated()
+        result.screenContext = screenContext?.validated()
+        return result
+    }
+
+    package func diagnostics() -> CrumbDiagnosticsSnapshot {
+        CrumbDiagnosticsSnapshot(
+            capturedAt: capturedAt, location: "react_native_javascript_failure",
+            processName: CrumbLogSanitizer.sanitize(processName), processID: processID,
+            cpuUsagePercent: cpuUsagePercent, residentMemoryBytes: residentMemoryBytes,
+            physicalFootprintBytes: physicalFootprintBytes, thermalState: thermalState,
+            threadCount: threadCount ?? 0, busiestThreads: [], gpuStatus: "unavailable_on_demand",
+            network: CrumbNetworkDiagnostic(status: networkStatus, transport: networkTransport,
+                cellularGeneration: nil, isExpensive: networkExpensive,
+                isConstrained: networkConstrained, healthCheck: nil),
+            logs: CrumbLogDiagnostic(status: .unavailable, sources: [], entries: [],
+                truncated: false, droppedEntryCount: 0, failures: []),
+            stackTraces: stacks?.diagnostic ?? CrumbStackTraceDiagnostic(status: .unavailable, scope: "none",
+                threads: [], truncated: false, unavailableReason: "native_stacks_not_captured_during_javascript_failure"), rendering: rendering, screenContext: screenContext
+        )
+    }
+
+    /// Only invoked for an opted-in JavaScript handoff. No provider callbacks or HTTP probes.
+    package static func capture(settings: CrumbReportSettings) -> Self {
+        let capturedAt = Date()
+        let rendering = CrumbRenderingBuffer.capture(settings: settings)
+        let performance = settings.evidence.contains(.performance)
+        let memory = performance ? memorySnapshot() : nil
+        let threads = performance ? threadSnapshot() : (nil, nil)
+        let network = settings.evidence.contains(.network) ? networkSnapshot() : nil
+        return Self(screenContext: settings.screenContext, rendering: rendering, stacks: settings.evidence.contains(.threadStacks) ? CrumbFailureStacks.capture() : nil, capturedAt: capturedAt,
+            processName: String(CrumbLogSanitizer.sanitize(ProcessInfo.processInfo.processName).prefix(128)),
+            processID: ProcessInfo.processInfo.processIdentifier,
+            cpuUsagePercent: threads.1, residentMemoryBytes: memory?.0,
+            physicalFootprintBytes: memory?.1, threadCount: threads.0,
+            thermalState: performance ? thermalSnapshot() : "unavailable",
+            networkStatus: network?.0 ?? "unknown", networkTransport: network?.1 ?? "unknown",
+            networkExpensive: network?.2 ?? false, networkConstrained: network?.3 ?? false)
+    }
+
+    private static func memorySnapshot() -> (UInt64, UInt64)? {
+        #if canImport(Darwin)
+        var info = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
+        let result = withUnsafeMutablePointer(to: &info) { pointer in
+            pointer.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
+            }
+        }
+        return result == KERN_SUCCESS ? (UInt64(info.resident_size), UInt64(info.phys_footprint)) : nil
+        #else
+        return nil
+        #endif
+    }
+
+    private static func threadSnapshot() -> (Int?, Double?) {
+        #if canImport(Darwin)
+        var list: thread_act_array_t?
+        var count: mach_msg_type_number_t = 0
+        guard task_threads(mach_task_self_, &list, &count) == KERN_SUCCESS, let list else { return (nil, nil) }
+        defer {
+            for index in 0..<Int(count) { mach_port_deallocate(mach_task_self_, list[index]) }
+            vm_deallocate(mach_task_self_, vm_address_t(UInt(bitPattern: list)),
+                vm_size_t(Int(count) * MemoryLayout<thread_t>.stride))
+        }
+        // Count all threads, but never perform an unbounded per-thread diagnostic walk.
+        guard count <= 256 else { return (Int(count), nil) }
+        var cpu = 0.0
+        for index in 0..<Int(count) {
+            var info = thread_basic_info_data_t()
+            var infoCount = mach_msg_type_number_t(MemoryLayout<thread_basic_info_data_t>.size / MemoryLayout<integer_t>.size)
+            let result = withUnsafeMutablePointer(to: &info) { pointer in
+                pointer.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) {
+                    thread_info(list[index], thread_flavor_t(THREAD_BASIC_INFO), $0, &infoCount)
+                }
+            }
+            guard result == KERN_SUCCESS else { return (Int(count), nil) }
+            if info.flags & TH_FLAGS_IDLE == 0 { cpu += Double(info.cpu_usage) / Double(TH_USAGE_SCALE) * 100 }
+        }
+        return (Int(count), cpu)
+        #else
+        return (nil, nil)
+        #endif
+    }
+
+    private static func thermalSnapshot() -> String {
+        #if canImport(Darwin)
+        switch ProcessInfo.processInfo.thermalState {
+        case .nominal: return "nominal"
+        case .fair: return "fair"
+        case .serious: return "serious"
+        case .critical: return "critical"
+        @unknown default: return "unknown"
+        }
+        #else
+        return "unavailable"
+        #endif
+    }
+
+    private static func networkSnapshot() -> (String, String, Bool, Bool)? {
+        #if canImport(Network)
+        let monitor = NWPathMonitor()
+        let result = FailurePathBox()
+        let ready = DispatchSemaphore(value: 0)
+        monitor.pathUpdateHandler = { path in result.set(path); ready.signal() }
+        monitor.start(queue: DispatchQueue(label: "dev.crumb.failure-connectivity"))
+        defer { monitor.cancel() }
+        // A local connectivity observation only; no network requests and no long wait on failure.
+        guard ready.wait(timeout: .now() + .milliseconds(30)) == .success, let path = result.get() else { return nil }
+        let transport = path.usesInterfaceType(.wifi) ? "wifi" :
+            path.usesInterfaceType(.cellular) ? "cellular" :
+            path.usesInterfaceType(.wiredEthernet) ? "ethernet" :
+            path.status == .satisfied ? "other" : "none"
+        return (path.status == .satisfied ? "reachable" : "unreachable", transport, path.isExpensive, path.isConstrained)
+        #else
+        return nil
+        #endif
+    }
+}
+
+#if canImport(Network)
+private final class FailurePathBox: @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: NWPath?
+    func set(_ path: NWPath) { lock.lock(); defer { lock.unlock() }; value = path }
+    func get() -> NWPath? { lock.lock(); defer { lock.unlock() }; return value }
+}
+#endif

package/native/ios/packages/ios/Sources/CrumbCore/CrumbLogs.swift

@@ -0,0 +1,138 @@
+import Foundation
+
+public enum CrumbLogLevel: String, Equatable, Sendable {
+    case debug
+    case info
+    case notice
+    case warning
+    case error
+    case fault
+}
+
+public struct CrumbLogEntry: Equatable, Sendable {
+    public let timestamp: Date
+    public let level: CrumbLogLevel
+    public let source: String
+    public let category: String
+    public let message: String
+
+    public init(
+        timestamp: Date,
+        level: CrumbLogLevel,
+        source: String = "application",
+        category: String,
+        message: String
+    ) {
+        self.timestamp = timestamp
+        self.level = level
+        self.source = source
+        self.category = category
+        self.message = message
+    }
+}
+
+/// Supplies already-buffered application logs when a report is explicitly opened.
+/// Implementations must be thread-safe and return promptly from an in-memory snapshot.
+public protocol CrumbLogProvider: AnyObject, Sendable {
+    func recentLogs() throws -> [CrumbLogEntry]
+}
+
+public struct CrumbLogOptions: Equatable, Sendable {
+    public let enabled: Bool
+    public let lookback: TimeInterval
+    public let maximumEntries: Int
+    public let maximumBytes: Int
+    public let provider: (any CrumbLogProvider)?
+
+    public init(
+        enabled: Bool = true,
+        lookback: TimeInterval = 60,
+        maximumEntries: Int = 200,
+        maximumBytes: Int = 65_536,
+        provider: (any CrumbLogProvider)? = nil
+    ) {
+        self.enabled = enabled
+        self.lookback = lookback
+        self.maximumEntries = maximumEntries
+        self.maximumBytes = maximumBytes
+        self.provider = provider
+    }
+
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        let sameProvider: Bool
+        switch (lhs.provider, rhs.provider) {
+        case (nil, nil):
+            sameProvider = true
+        case let (lhsProvider?, rhsProvider?):
+            sameProvider = lhsProvider === rhsProvider
+        default:
+            sameProvider = false
+        }
+
+        return lhs.enabled == rhs.enabled
+            && lhs.lookback == rhs.lookback
+            && lhs.maximumEntries == rhs.maximumEntries
+            && lhs.maximumBytes == rhs.maximumBytes
+            && sameProvider
+    }
+}
+
+public enum CrumbLogCaptureStatus: String, Equatable, Sendable {
+    case captured
+    case empty
+    case unavailable
+    case disabled
+    case disabledByPolicy = "disabled_by_policy"
+}
+
+public struct CrumbLogDiagnostic: Equatable, Sendable {
+    public let status: CrumbLogCaptureStatus
+    public let sources: [String]
+    public let entries: [CrumbLogEntry]
+    public let truncated: Bool
+    public let droppedEntryCount: Int
+    public let failures: [String]
+
+    public init(
+        status: CrumbLogCaptureStatus,
+        sources: [String],
+        entries: [CrumbLogEntry],
+        truncated: Bool,
+        droppedEntryCount: Int,
+        failures: [String]
+    ) {
+        self.status = status
+        self.sources = sources
+        self.entries = entries
+        self.truncated = truncated
+        self.droppedEntryCount = droppedEntryCount
+        self.failures = failures
+    }
+}
+
+package enum CrumbLogSanitizer {
+    package static func sanitize(_ value: String) -> String {
+        var sanitized = value
+        let replacements = [
+            (#"(?i)(https?://)[^/\s:@]+:[^/@\s]+@"#, "$1[REDACTED]@"),
+            (#"(?i)\bBearer\s+[A-Za-z0-9._~+/=-]+"#, "Bearer [REDACTED]"),
+            (
+                #"(?i)\b(authorization|cookie|set-cookie|password|passwd|secret|token|api[_-]?key)\s*[:=]\s*(\"[^\"]*\"|'[^']*'|[^\s,;]+)"#,
+                "$1=[REDACTED]"
+            ),
+            (#"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b"#, "[REDACTED_EMAIL]"),
+            (#"\b(?:\d[ -]*?){13,19}\b"#, "[REDACTED_NUMBER]"),
+            (#"([?&][A-Za-z0-9._~-]+)=([^&#\s]*)"#, "$1=[REDACTED]"),
+            (#"[\u0000-\u001F\u007F]"#, " ")
+        ]
+
+        for (pattern, replacement) in replacements {
+            sanitized = sanitized.replacingOccurrences(
+                of: pattern,
+                with: replacement,
+                options: .regularExpression
+            )
+        }
+        return sanitized
+    }
+}

package/native/ios/packages/ios/Sources/CrumbCore/CrumbPolicy.swift

@@ -0,0 +1,336 @@
+import CryptoKit
+import Foundation
+
+/// Version for the public, host-owned configuration contract. It is separate
+/// from the report-envelope schema version.
+public enum CrumbConfigurationContract {
+    public static let version = "1.0"
+}
+
+public enum CrumbPolicyStatus: String, Codable, Equatable, Sendable {
+    case notConfigured = "not_configured"
+    case notFetched = "not_fetched"
+    case fetching
+    case fresh
+    case cached
+    case unavailable
+    case expired
+}
+
+package enum CrumbPolicySource {
+    case fresh
+    case cached
+}
+
+public enum CrumbWorkspacePolicyError: Error, Equatable {
+    case invalid
+    case unsupportedSchema
+    case expired
+}
+
+/// The only remote control surface in v1. A policy can remove locally enabled
+/// evidence, hide the optional category field, and further narrow the host's
+/// custom-context allowlist. It has no fields that can enable collection,
+/// change reporter layout, or replace Crumb copy and branding.
+public struct CrumbWorkspacePolicy: Equatable, Sendable {
+    public static let schemaVersion = "1.0"
+
+    public let version: Int
+    public let expiresAt: Date
+    public let disabledEvidence: Set<CrumbEvidenceCategory>
+    public let hiddenReporterFields: Set<CrumbReporterField>
+    public let allowedContextKeys: Set<String>
+
+    public init(
+        version: Int,
+        expiresAt: Date,
+        disabledEvidence: Set<CrumbEvidenceCategory> = [],
+        hiddenReporterFields: Set<CrumbReporterField> = [],
+        allowedContextKeys: Set<String> = []
+    ) {
+        self.version = version
+        self.expiresAt = expiresAt
+        self.disabledEvidence = disabledEvidence
+        self.hiddenReporterFields = hiddenReporterFields
+        self.allowedContextKeys = allowedContextKeys
+    }
+
+    public static func decode(
+        _ data: Data,
+        now: Date = Date()
+    ) throws -> CrumbWorkspacePolicy {
+        guard data.count <= 65_536,
+              let object = try? JSONSerialization.jsonObject(with: data),
+              let dictionary = object as? [String: Any]
+        else {
+            throw CrumbWorkspacePolicyError.invalid
+        }
+
+        let expectedKeys: Set<String> = [
+            "schema_version",
+            "version",
+            "expires_at",
+            "disabled_evidence",
+            "hidden_reporter_fields",
+            "allowed_context_keys"
+        ]
+        guard Set(dictionary.keys) == expectedKeys else {
+            throw CrumbWorkspacePolicyError.invalid
+        }
+        guard dictionary["schema_version"] as? String == schemaVersion else {
+            throw CrumbWorkspacePolicyError.unsupportedSchema
+        }
+        guard let version = dictionary["version"] as? Int, (1...Int.max).contains(version),
+              let expiresText = dictionary["expires_at"] as? String,
+              let expiresAt = parseISO8601(expiresText)
+        else {
+            throw CrumbWorkspacePolicyError.invalid
+        }
+        guard expiresAt > now else {
+            throw CrumbWorkspacePolicyError.expired
+        }
+
+        let disabledEvidence = try parseEnumSet(
+            dictionary["disabled_evidence"],
+            as: CrumbEvidenceCategory.self,
+            maximum: CrumbEvidenceCategory.allCases.count
+        )
+        let hiddenReporterFields = try parseEnumSet(
+            dictionary["hidden_reporter_fields"],
+            as: CrumbReporterField.self,
+            maximum: CrumbReporterField.allCases.count
+        )
+        guard !hiddenReporterFields.contains(.description) else {
+            // The description is the required text report and may not be
+            // removed by a workspace policy.
+            throw CrumbWorkspacePolicyError.invalid
+        }
+        let allowedContextKeys = try parseStringSet(
+            dictionary["allowed_context_keys"],
+            maximum: 16,
+            maximumLength: 64
+        )
+        return CrumbWorkspacePolicy(
+            version: version,
+            expiresAt: expiresAt,
+            disabledEvidence: disabledEvidence,
+            hiddenReporterFields: hiddenReporterFields,
+            allowedContextKeys: allowedContextKeys
+        )
+    }
+
+    private static func parseISO8601(_ value: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: value) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: value)
+    }
+
+    private static func parseEnumSet<Enum: RawRepresentable & Hashable>(
+        _ value: Any?,
+        as type: Enum.Type,
+        maximum: Int
+    ) throws -> Set<Enum> where Enum.RawValue == String {
+        guard let values = value as? [String],
+              values.count <= maximum,
+              Set(values).count == values.count,
+              values.allSatisfy({ type.init(rawValue: $0) != nil })
+        else {
+            throw CrumbWorkspacePolicyError.invalid
+        }
+        return Set(values.compactMap(type.init(rawValue:)))
+    }
+
+    private static func parseStringSet(
+        _ value: Any?,
+        maximum: Int,
+        maximumLength: Int
+    ) throws -> Set<String> {
+        guard let values = value as? [String],
+              values.count <= maximum,
+              Set(values).count == values.count,
+              values.allSatisfy({ CrumbCustomContextSanitizer.isValidKey($0, maximum: maximumLength) })
+        else {
+            throw CrumbWorkspacePolicyError.invalid
+        }
+        return Set(values)
+    }
+
+    package func isValid(at now: Date) -> Bool {
+        version > 0 &&
+            expiresAt > now &&
+            disabledEvidence.count <= CrumbEvidenceCategory.allCases.count &&
+            hiddenReporterFields.count <= CrumbReporterField.allCases.count &&
+            !hiddenReporterFields.contains(.description) &&
+            allowedContextKeys.count <= CrumbCustomContextSanitizer.maximumKeys &&
+            allowedContextKeys.allSatisfy({ CrumbCustomContextSanitizer.isValidKey($0) })
+    }
+}
+
+public struct CrumbEffectivePolicy: Equatable, Sendable {
+    public let evidence: Set<CrumbEvidenceCategory>
+    public let reporterFields: Set<CrumbReporterField>
+    public let customContext: [String: String]
+    public let status: CrumbPolicyStatus
+    public let workspacePolicyVersion: Int?
+
+    public var hasValidWorkspacePolicy: Bool {
+        status == .fresh || status == .cached
+    }
+}
+
+public enum CrumbPolicyEvaluator {
+    public static func localEvidence(for configuration: CrumbConfiguration) -> Set<CrumbEvidenceCategory> {
+        var evidence = configuration.evidence
+        if !configuration.capture.screenshot {
+            evidence.remove(.screenshot)
+        }
+        if !configuration.diagnostics.logs.enabled {
+            evidence.remove(.logs)
+        }
+        if configuration.diagnostics.healthCheckURL == nil {
+            evidence.remove(.healthCheck)
+        }
+        return evidence
+    }
+
+    public static func effective(
+        for configuration: CrumbConfiguration,
+        workspacePolicy: CrumbWorkspacePolicy?,
+        status: CrumbPolicyStatus,
+        now: Date = Date()
+    ) -> CrumbEffectivePolicy {
+        let localEvidence = localEvidence(for: configuration)
+        let localContext = localEvidence.contains(.customContext)
+            ? CrumbCustomContextSanitizer.sanitize(configuration.customContext)
+            : [:]
+        let requiresWorkspacePolicy = configuration.workspacePolicy.url != nil
+        let policyIsValid = requiresWorkspacePolicy
+            && workspacePolicy?.isValid(at: now) == true
+            && (status == .fresh || status == .cached)
+
+        if !requiresWorkspacePolicy {
+            return CrumbEffectivePolicy(
+                evidence: localEvidence,
+                reporterFields: configuration.reporter.visibleFields,
+                customContext: localContext,
+                status: .notConfigured,
+                workspacePolicyVersion: nil
+            )
+        }
+
+        guard policyIsValid, let workspacePolicy else {
+            return CrumbEffectivePolicy(
+                evidence: [],
+                reporterFields: configuration.reporter.visibleFields.intersection([.description]),
+                customContext: [:],
+                status: status == .expired ? .expired : status,
+                workspacePolicyVersion: nil
+            )
+        }
+
+        var evidence = localEvidence
+        evidence.subtract(workspacePolicy.disabledEvidence)
+        var reporterFields = configuration.reporter.visibleFields
+        reporterFields.subtract(workspacePolicy.hiddenReporterFields)
+        reporterFields.insert(.description)
+        let customContext = evidence.contains(.customContext)
+            ? CrumbCustomContextSanitizer.sanitize(
+                configuration.customContext,
+                allowedByPolicy: workspacePolicy.allowedContextKeys
+            )
+            : [:]
+        return CrumbEffectivePolicy(
+            evidence: evidence,
+            reporterFields: reporterFields,
+            customContext: customContext,
+            status: status,
+            workspacePolicyVersion: workspacePolicy.version
+        )
+    }
+
+}
+
+public enum CrumbCustomContextSanitizer {
+    public static let maximumKeys = 16
+    public static let maximumKeyLength = 64
+    public static let maximumValueBytes = 512
+    public static let maximumTotalBytes = 8_192
+
+    public static func sanitize(
+        _ options: CrumbCustomContextOptions,
+        allowedByPolicy: Set<String>? = nil
+    ) -> [String: String] {
+        let policyKeys = allowedByPolicy ?? options.allowedKeys
+        let allowedKeys = options.allowedKeys.intersection(policyKeys)
+            .filter { isValidKey($0, maximum: maximumKeyLength) }
+            .sorted()
+        var result: [String: String] = [:]
+        var totalBytes = 0
+
+        for key in allowedKeys.prefix(maximumKeys) {
+            guard let supplied = options.values[key] else { continue }
+            guard !isSensitiveKey(key) else { continue }
+            let sanitized = CrumbLogSanitizer.sanitize(supplied)
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+            guard !sanitized.isEmpty else { continue }
+            let value = truncateUTF8(sanitized, maximumBytes: maximumValueBytes)
+            let entryBytes = key.utf8.count + value.utf8.count
+            guard totalBytes + entryBytes <= maximumTotalBytes else { break }
+            result[key] = value
+            totalBytes += entryBytes
+        }
+        return result
+    }
+
+    package static func isValidKey(_ value: String, maximum: Int = maximumKeyLength) -> Bool {
+        guard value.unicodeScalars.count <= maximum else { return false }
+        return value.range(of: #"^[A-Za-z][A-Za-z0-9_.-]*$"#, options: .regularExpression) != nil
+    }
+
+    private static func isSensitiveKey(_ key: String) -> Bool {
+        let lowered = key.lowercased()
+        return [
+            "password", "passwd", "secret", "token", "authorization", "cookie",
+            "api_key", "apikey", "access_key", "private_key", "card", "cvv", "cvc",
+            "ssn", "email", "phone", "address"
+        ].contains { lowered.contains($0) }
+    }
+
+    private static func truncateUTF8(_ value: String, maximumBytes: Int) -> String {
+        guard value.utf8.count > maximumBytes else { return value }
+        var result = ""
+        result.reserveCapacity(value.count)
+        for character in value {
+            let candidate = result + String(character)
+            guard candidate.utf8.count <= maximumBytes - 3 else { break }
+            result = candidate
+        }
+        return result + "…"
+    }
+}
+
+package struct CrumbPolicyFetchSettings: Sendable {
+    package let projectKey: String
+    package let url: URL
+    package let timeout: TimeInterval
+
+    package init(projectKey: String, url: URL, timeout: TimeInterval) {
+        self.projectKey = projectKey
+        self.url = url
+        self.timeout = timeout
+    }
+}
+
+package enum CrumbPolicyCache {
+    package static let maximumBytes = 65_536
+
+    package static func load(
+        data: Data?,
+        now: Date = Date()
+    ) -> CrumbWorkspacePolicy? {
+        guard let data, data.count <= maximumBytes else { return nil }
+        return try? CrumbWorkspacePolicy.decode(data, now: now)
+    }
+}