@scalebun-release/react-native 2.5.0

package/ios/Profiler/ScaleBunProfilerModule.swift

@@ -0,0 +1,966 @@
+import Foundation
+import UIKit
+import Darwin
+import React
+
+private let THREAD_BASIC_INFO_COUNT_VAL = mach_msg_type_number_t(
+    MemoryLayout<thread_basic_info_data_t>.size / MemoryLayout<natural_t>.size
+)
+
+/**
+ * ScaleBun Profiler — iOS Native Module (Phase 2)
+ *
+ * NATIVE-FIRST: This module owns ALL profiling logic on iOS.
+ * - CPU sampling via task_info / thread_info (public Mach APIs)
+ * - Memory sampling via task_vm_info / os_proc_available_memory
+ * - Thread enumeration via task_threads (public Mach API)
+ * - Frame timing via CADisplayLink
+ * - Thermal state via ProcessInfo
+ * - Incident detection
+ * - Batching and scheduling via DispatchSourceTimer
+ *
+ * JS receives pre-batched, pre-aggregated payloads only.
+ * Zero JS timers. Zero JS sampling loops. Zero JS aggregation.
+ */
+@objc(ScaleBunProfiler)
+class ScaleBunProfilerModule: RCTEventEmitter {
+
+    private var running = false
+    private var paused = false
+    private var sessionId: String = ""
+    private var currentScreen: String = ""
+
+    // Collectors
+    private var cpuCollector: IosCpuCollector?
+    private var memoryCollector: IosMemoryCollector?
+    private var threadCollector: IosThreadCollector?
+    private var renderCollector: IosRenderCollector?
+    private var thermalCollector: IosThermalCollector?
+    private var incidentDetector: IosIncidentDetector?
+
+    // Scheduler
+    private let schedulerQueue = DispatchQueue(label: "com.scalebun.profiler.scheduler", qos: .utility)
+    private var compositeTimer: DispatchSourceTimer?
+    private var threadTimer: DispatchSourceTimer?
+    private var batchId: Int64 = 0
+
+    // Config
+    private var compositeIntervalMs: Int64 = 2000
+    private var threadIntervalMs: Int64 = 3000
+
+    override init() {
+        cpuCollector = nil
+        memoryCollector = nil
+        threadCollector = nil
+        renderCollector = nil
+        thermalCollector = nil
+        incidentDetector = nil
+        compositeTimer = nil
+        threadTimer = nil
+        super.init()
+    }
+
+    // ─── Module Setup ───────────────────────────────────────────────────
+
+    @objc override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    override func supportedEvents() -> [String]! {
+        return [
+            "ScaleBunProfiler_SampleBatch",
+            "ScaleBunProfiler_Incident",
+            "ScaleBunProfiler_ScreenSummary",
+            "ScaleBunProfiler_ThreadSnapshot",
+            "ScaleBunProfiler_Capabilities",
+            "ScaleBunProfiler_StateChanged"
+        ]
+    }
+
+    // ─── Lifecycle ──────────────────────────────────────────────────────
+
+    @objc func startProfiler(_ config: NSDictionary,
+                              resolver resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard !running else {
+            resolve(true)
+            return
+        }
+
+        // Parse config
+        let cpuIntervalMs = config["cpuSampleIntervalMs"] as? Int64 ?? 1000
+        compositeIntervalMs = config["memorySampleIntervalMs"] as? Int64 ?? 2000
+        threadIntervalMs = config["threadSampleIntervalMs"] as? Int64 ?? 3000
+
+        // Initialize collectors
+        cpuCollector = IosCpuCollector()
+        memoryCollector = IosMemoryCollector()
+        threadCollector = IosThreadCollector()
+        renderCollector = IosRenderCollector()
+        thermalCollector = IosThermalCollector()
+        incidentDetector = IosIncidentDetector()
+
+        // Apply incident thresholds
+        if let thresholds = config["incidentThresholds"] as? [String: Any] {
+            incidentDetector?.updateThresholds(thresholds)
+        }
+
+        // Start render collector on main thread
+        DispatchQueue.main.async { [weak self] in
+            self?.renderCollector?.start()
+        }
+
+        // Start thermal monitoring
+        thermalCollector?.start()
+
+        // Seed CPU collector (needs one pre-sample)
+        schedulerQueue.async { [weak self] in
+            _ = self?.cpuCollector?.collect()
+        }
+
+        // Start composite timer
+        startCompositeTimer()
+        startThreadTimer()
+
+        running = true
+        paused = false
+
+        // Emit capabilities and state
+        emitCapabilities()
+        sendEvent(withName: "ScaleBunProfiler_StateChanged", body: ["state": "running"])
+
+        resolve(true)
+    }
+
+    @objc func stopProfiler(_ resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+        stopTimers()
+
+        DispatchQueue.main.async { [weak self] in
+            self?.renderCollector?.stop()
+        }
+        thermalCollector?.stop()
+
+        cpuCollector = nil
+        memoryCollector = nil
+        threadCollector = nil
+        renderCollector = nil
+        thermalCollector = nil
+        incidentDetector = nil
+
+        running = false
+        paused = false
+
+        sendEvent(withName: "ScaleBunProfiler_StateChanged", body: ["state": "idle"])
+        resolve(true)
+    }
+
+    @objc func pauseProfilerStream(_ resolve: @escaping RCTPromiseResolveBlock,
+                                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        paused = true
+        sendEvent(withName: "ScaleBunProfiler_StateChanged", body: ["state": "paused"])
+        resolve(true)
+    }
+
+    @objc func resumeProfilerStream(_ resolve: @escaping RCTPromiseResolveBlock,
+                                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        paused = false
+        sendEvent(withName: "ScaleBunProfiler_StateChanged", body: ["state": "running"])
+        resolve(true)
+    }
+
+    @objc func captureProfilerSnapshot(_ resolve: @escaping RCTPromiseResolveBlock,
+                                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        schedulerQueue.async { [weak self] in
+            let snapshot = self?.buildCompositeSample() ?? [:]
+            resolve(snapshot)
+        }
+    }
+
+    @objc func setProfilerConfig(_ config: NSDictionary,
+                                  resolver resolve: @escaping RCTPromiseResolveBlock,
+                                  rejecter reject: @escaping RCTPromiseRejectBlock) {
+        if let thresholds = config["incidentThresholds"] as? [String: Any] {
+            incidentDetector?.updateThresholds(thresholds)
+        }
+        resolve(true)
+    }
+
+    @objc func markProfilerSpan(_ spanName: String,
+                                 spanId: String,
+                                 metadata: NSDictionary?,
+                                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(true) // Phase 4
+    }
+
+    @objc func endProfilerSpan(_ spanId: String,
+                                resolver resolve: @escaping RCTPromiseResolveBlock,
+                                rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(true) // Phase 4
+    }
+
+    @objc func markProfilerInteraction(_ interactionId: String,
+                                        interactionName: String,
+                                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(true) // Phase 4
+    }
+
+    @objc func flushProfilerExport(_ resolve: @escaping RCTPromiseResolveBlock,
+                                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(["status": "export_not_yet_implemented"])
+    }
+
+    @objc func getProfilerCapabilities(_ resolve: @escaping RCTPromiseResolveBlock,
+                                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(buildCapabilities())
+    }
+
+    @objc func setCurrentScreen(_ screenName: String,
+                                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        currentScreen = screenName
+        resolve(true)
+    }
+
+    @objc func setSessionId(_ sessionId: String,
+                              resolver resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        self.sessionId = sessionId
+        resolve(true)
+    }
+
+    // ─── Scheduler ──────────────────────────────────────────────────────
+
+    private func startCompositeTimer() {
+        let timer = DispatchSource.makeTimerSource(queue: schedulerQueue)
+        timer.schedule(deadline: .now() + .milliseconds(Int(compositeIntervalMs + 200)),
+                       repeating: .milliseconds(Int(compositeIntervalMs)))
+        timer.setEventHandler { [weak self] in
+            self?.emitCompositeBatch()
+        }
+        timer.resume()
+        compositeTimer = timer
+    }
+
+    private func startThreadTimer() {
+        let timer = DispatchSource.makeTimerSource(queue: schedulerQueue)
+        timer.schedule(deadline: .now() + .milliseconds(Int(threadIntervalMs + 500)),
+                       repeating: .milliseconds(Int(threadIntervalMs)))
+        timer.setEventHandler { [weak self] in
+            self?.emitThreadSnapshot()
+        }
+        timer.resume()
+        threadTimer = timer
+    }
+
+    private func stopTimers() {
+        compositeTimer?.cancel()
+        compositeTimer = nil
+        threadTimer?.cancel()
+        threadTimer = nil
+    }
+
+    // ─── Batch Emission ─────────────────────────────────────────────────
+
+    private func emitCompositeBatch() {
+        guard !paused else { return }
+
+        let batch = buildCompositeSample()
+        sendEvent(withName: "ScaleBunProfiler_SampleBatch", body: batch)
+
+        // Incident detection
+        if let detector = incidentDetector {
+            let incidents = detector.evaluate(
+                cpu: batch["cpu"] as? [String: Any],
+                memory: batch["memory"] as? [String: Any],
+                render: batch["render"] as? [String: Any],
+                thermal: batch["thermal"] as? [String: Any],
+                memoryGrowthRate: memoryCollector?.getGrowthRate(),
+                currentScreen: currentScreen
+            )
+            for incident in incidents {
+                sendEvent(withName: "ScaleBunProfiler_Incident", body: incident)
+            }
+        }
+    }
+
+    private func emitThreadSnapshot() {
+        guard !paused, let collector = threadCollector else { return }
+        let snapshot = collector.collect()
+        sendEvent(withName: "ScaleBunProfiler_ThreadSnapshot", body: snapshot)
+    }
+
+    private func buildCompositeSample() -> [String: Any] {
+        batchId += 1
+        var batch: [String: Any] = [
+            "id": "sample_\(batchId)_\(Int(Date().timeIntervalSince1970 * 1000))",
+            "timestamp": Date().timeIntervalSince1970 * 1000,
+            "sampleIntervalMs": compositeIntervalMs,
+            "screenKey": currentScreen,
+            "sessionId": sessionId
+        ]
+
+        if let cpu = cpuCollector?.collect() { batch["cpu"] = cpu }
+        if let mem = memoryCollector?.collect() { batch["memory"] = mem }
+
+        // Render collector must be read from main thread
+        var renderData: [String: Any]?
+        if Thread.isMainThread {
+            renderData = renderCollector?.collect()
+        } else {
+            DispatchQueue.main.sync {
+                renderData = self.renderCollector?.collect()
+            }
+        }
+        if let render = renderData { batch["render"] = render }
+
+        if let thermal = thermalCollector?.collect() { batch["thermal"] = thermal }
+
+        return batch
+    }
+
+    // ─── Capabilities ───────────────────────────────────────────────────
+
+    private func buildCapabilities() -> [String: Any] {
+        let osVersion = ProcessInfo.processInfo.operatingSystemVersion
+        let versionString = "\(osVersion.majorVersion).\(osVersion.minorVersion).\(osVersion.patchVersion)"
+
+        var caps: [String: Any] = [
+            "platform": "ios",
+            "deviceModel": deviceModel(),
+            "osVersion": versionString,
+            "buildType": isDebugBuild() ? "debug" : "release"
+        ]
+
+        caps["cpu"] = buildCapEntry(
+            available: true, minVersion: "iOS 13", liveSupported: true,
+            reason: "Thread-sum approach: task_threads + thread_info.cpu_usage (kernel scheduler estimate). Same method as Activity Monitor. Normalized by activeProcessorCount."
+        )
+
+        caps["memory"] = buildCapEntry(
+            available: true, minVersion: "iOS 13", liveSupported: true,
+            reason: "Physical footprint via task_vm_info, available memory via os_proc_available_memory"
+        )
+
+        caps["threads"] = buildCapEntry(
+            available: true, minVersion: "iOS 13", liveSupported: true,
+            reason: "App-level thread enumeration via task_threads (Mach API). Shows process threads only, not system-wide. Per-thread CPU% is kernel scheduler estimate. Thread names available via pthread_getname_np. Capped at 50 threads."
+        )
+
+        caps["render"] = buildCapEntry(
+            available: true, minVersion: "iOS 13", liveSupported: true,
+            reason: "Frame timing via CADisplayLink on main thread"
+        )
+
+        caps["network"] = buildCapEntry(
+            available: false, minVersion: "N/A", liveSupported: false,
+            reason: "Network profiling via correlation layer (Phase 4)"
+        )
+
+        caps["js"] = buildCapEntry(
+            available: true, minVersion: "iOS 13", liveSupported: true,
+            reason: "JS event loop stall detection via lightweight heartbeat in JS layer. Opt-in, low overhead."
+        )
+
+        caps["thermal"] = buildCapEntry(
+            available: true, minVersion: "iOS 11", liveSupported: true,
+            reason: "Thermal state via ProcessInfo.thermalState + NotificationCenter observer"
+        )
+
+        caps["diskIo"] = buildCapEntry(
+            available: false, minVersion: "N/A", liveSupported: false,
+            reason: "No public disk I/O measurement API on iOS"
+        )
+
+        return caps
+    }
+
+    private func buildCapEntry(available: Bool, minVersion: String, liveSupported: Bool, reason: String? = nil) -> [String: Any] {
+        var entry: [String: Any] = [
+            "available": available,
+            "minVersion": minVersion,
+            "currentVersion": "iOS \(ProcessInfo.processInfo.operatingSystemVersion.majorVersion)",
+            "liveSupported": liveSupported
+        ]
+        if let r = reason { entry["reason"] = r }
+        return entry
+    }
+
+    private func emitCapabilities() {
+        sendEvent(withName: "ScaleBunProfiler_Capabilities", body: buildCapabilities())
+    }
+
+    /** Shared with the replay lane so the two cannot report different models for one device. */
+    private func deviceModel() -> String {
+        return ScaleBunDeviceIdentity.modelIdentifier()
+    }
+
+    private func isDebugBuild() -> Bool {
+        #if DEBUG
+        return true
+        #else
+        return false
+        #endif
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - CPU Collector (Thread-Sum approach via task_threads + thread_info)
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * IosCpuCollector — Accurate iOS CPU measurement.
+ *
+ * APPROACH: Thread-sum via task_threads() + thread_info(THREAD_BASIC_INFO).
+ *
+ * Why thread-sum instead of task_basic_info:
+ * - task_basic_info provides accumulated user_time + system_time across the
+ *   entire process lifetime, INCLUDING terminated threads. Computing a delta
+ *   over wall clock can include stale values from threads that no longer exist.
+ * - thread_info(THREAD_BASIC_INFO).cpu_usage gives the kernel's own
+ *   scheduler-computed per-thread CPU usage (scale: TH_USAGE_SCALE = 1000).
+ *   Summing across all live threads gives instantaneous CPU usage.
+ *
+ * This is the same approach used by Apple's own Activity Monitor and Instruments.
+ * All Mach APIs used here are public.
+ *
+ * NOTE: The result can exceed 100% on multi-core devices (e.g., 400% on a
+ * quad-core when all cores are busy). We normalize by activeProcessorCount
+ * to get 0–100% "how busy is the device running our process" percentage.
+ */
+class IosCpuCollector {
+
+    func collect() -> [String: Any]? {
+        var threadList: thread_act_array_t?
+        var threadCount: mach_msg_type_number_t = 0
+
+        let kr = task_threads(mach_task_self_, &threadList, &threadCount)
+        guard kr == KERN_SUCCESS, let threads = threadList else {
+            return ["appCpuPercent": 0.0, "availability": "degraded"]
+        }
+
+        var totalCpuUsage: Double = 0.0
+        let count = Int(threadCount)
+
+        for i in 0..<count {
+            var info = thread_basic_info_data_t()
+            var infoCount = THREAD_BASIC_INFO_COUNT_VAL
+
+            let result = withUnsafeMutablePointer(to: &info) {
+                $0.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) {
+                    thread_info(threads[i], thread_flavor_t(THREAD_BASIC_INFO), $0, &infoCount)
+                }
+            }
+
+            if result == KERN_SUCCESS && (info.flags & TH_FLAGS_IDLE) == 0 {
+                // cpu_usage is on a scale of 0 to TH_USAGE_SCALE (1000)
+                // Convert to percentage: (cpu_usage / TH_USAGE_SCALE) * 100
+                totalCpuUsage += Double(info.cpu_usage) / Double(TH_USAGE_SCALE) * 100.0
+            }
+        }
+
+        // Deallocate thread list
+        let size = MemoryLayout<thread_act_t>.size * count
+        vm_deallocate(mach_task_self_, vm_address_t(bitPattern: threads), vm_size_t(size))
+
+        // Normalize: totalCpuUsage can be > 100% on multi-core.
+        // Divide by activeProcessorCount for "percentage of total CPU capacity".
+        let coreCount = Double(ProcessInfo.processInfo.activeProcessorCount)
+        let normalizedPercent = (totalCpuUsage / max(coreCount, 1.0)).clamped(to: 0...100)
+
+        return [
+            "appCpuPercent": round(normalizedPercent * 10.0) / 10.0,
+            // Also export raw multi-core total for tools that want per-core view
+            "rawMultiCoreCpuPercent": round(totalCpuUsage * 10.0) / 10.0,
+            "processCpuTimeMs": 0.0, // Not tracked in thread-sum approach
+            "availability": "available"
+        ]
+    }
+}
+
+private extension Double {
+    func clamped(to range: ClosedRange<Double>) -> Double {
+        return min(max(self, range.lowerBound), range.upperBound)
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - Memory Collector (task_vm_info + os_proc_available_memory)
+// ═══════════════════════════════════════════════════════════════════════════
+
+class IosMemoryCollector {
+    private var peakMemoryBytes: UInt64 = 0
+    private var prevResidentBytes: UInt64 = 0
+    private var prevTimestamp: TimeInterval = 0
+
+    func collect() -> [String: Any] {
+        var result: [String: Any] = [:]
+
+        // Physical footprint via task_vm_info (Mach API — public)
+        var vmInfo = task_vm_info_data_t()
+        var vmCount = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
+
+        let vmResult = withUnsafeMutablePointer(to: &vmInfo) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(vmCount)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &vmCount)
+            }
+        }
+
+        if vmResult == KERN_SUCCESS {
+            let physicalFootprint = UInt64(vmInfo.phys_footprint)
+            let residentSize = UInt64(vmInfo.resident_size)
+            let internalBytes = UInt64(vmInfo.internal)
+            let compressedBytes = UInt64(vmInfo.compressed)
+
+            result["residentBytes"] = physicalFootprint
+            result["usedHeapBytes"] = physicalFootprint
+            result["totalHeapBytes"] = residentSize
+
+            if physicalFootprint > peakMemoryBytes {
+                peakMemoryBytes = physicalFootprint
+            }
+            result["peakMemoryBytes"] = peakMemoryBytes
+
+            prevResidentBytes = physicalFootprint
+            prevTimestamp = ProcessInfo.processInfo.systemUptime
+        }
+
+        // Available memory (iOS 13+)
+        if #available(iOS 13.0, *) {
+            let available = os_proc_available_memory()
+            result["availableMemoryBytes"] = available
+
+            // Pressure level based on available memory
+            let pressureLevel: Int
+            if available < 50_000_000 { // < 50MB
+                pressureLevel = 2 // critical
+            } else if available < 200_000_000 { // < 200MB
+                pressureLevel = 1 // moderate
+            } else {
+                pressureLevel = 0 // normal
+            }
+            result["pressureLevel"] = pressureLevel
+            result["lowMemory"] = pressureLevel >= 2
+        } else {
+            result["pressureLevel"] = 0
+            result["lowMemory"] = false
+        }
+
+        result["availability"] = "available"
+        return result
+    }
+
+    func getGrowthRate() -> Double? {
+        let now = ProcessInfo.processInfo.systemUptime
+        guard prevTimestamp > 0, prevResidentBytes > 0 else { return nil }
+
+        let elapsed = now - prevTimestamp
+        guard elapsed > 0 else { return nil }
+
+        // Re-read current memory
+        var vmInfo = task_vm_info_data_t()
+        var vmCount = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size)
+
+        let vmResult = withUnsafeMutablePointer(to: &vmInfo) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(vmCount)) {
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &vmCount)
+            }
+        }
+
+        guard vmResult == KERN_SUCCESS else { return nil }
+
+        let current = UInt64(vmInfo.phys_footprint)
+        let growth = Int64(current) - Int64(prevResidentBytes)
+        return Double(growth) / elapsed
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - Thread Collector (Mach task_threads + thread_info)
+// ═══════════════════════════════════════════════════════════════════════════
+
+class IosThreadCollector {
+    private var peakThreadCount: Int = 0
+
+    func collect() -> [String: Any] {
+        var result: [String: Any] = [:]
+
+        var threadList: thread_act_array_t?
+        var threadCount: mach_msg_type_number_t = 0
+
+        let kr = task_threads(mach_task_self_, &threadList, &threadCount)
+        guard kr == KERN_SUCCESS, let threads = threadList else {
+            result["threadCount"] = 0
+            result["peakThreadCount"] = peakThreadCount
+            result["availability"] = "degraded"
+            return result
+        }
+
+        let count = Int(threadCount)
+        if count > peakThreadCount { peakThreadCount = count }
+
+        var threadArray: [[String: Any]] = []
+        let mainThreadId = pthread_mach_thread_np(pthread_self())
+
+        for i in 0..<min(count, 50) { // Cap at 50 to avoid chatty bridge
+            let thread = threads[i]
+            var info = thread_basic_info_data_t()
+            var infoCount = THREAD_BASIC_INFO_COUNT_VAL
+
+            let infoResult = withUnsafeMutablePointer(to: &info) {
+                $0.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) {
+                    thread_info(thread, thread_flavor_t(THREAD_BASIC_INFO), $0, &infoCount)
+                }
+            }
+
+            var threadEntry: [String: Any] = [
+                "id": Int(thread)
+            ]
+
+            // Get thread name
+            var threadName = [CChar](repeating: 0, count: 256)
+            if let pt = pthread_from_mach_thread_np(thread) {
+                pthread_getname_np(pt, &threadName, 256)
+            }
+            let name = String(cString: threadName)
+            threadEntry["name"] = name.isEmpty ? "Thread-\(i)" : name
+
+            // Classify role
+            threadEntry["role"] = classifyThread(name: name, machThread: thread, mainThreadId: mainThreadId)
+
+            if infoResult == KERN_SUCCESS {
+                // Thread state
+                switch info.run_state {
+                case TH_STATE_RUNNING: threadEntry["state"] = "running"
+                case TH_STATE_STOPPED: threadEntry["state"] = "blocked"
+                case TH_STATE_WAITING: threadEntry["state"] = "waiting"
+                case TH_STATE_UNINTERRUPTIBLE: threadEntry["state"] = "blocked"
+                case TH_STATE_HALTED: threadEntry["state"] = "sleeping"
+                default: threadEntry["state"] = "unknown"
+                }
+
+                // CPU usage for this thread
+                let cpuUsage = Double(info.cpu_usage) / Double(TH_USAGE_SCALE) * 100.0
+                threadEntry["cpuPercent"] = round(cpuUsage * 10.0) / 10.0
+            } else {
+                threadEntry["state"] = "unknown"
+            }
+
+            threadArray.append(threadEntry)
+        }
+
+        // Deallocate thread list
+        let size = MemoryLayout<thread_act_t>.size * count
+        vm_deallocate(mach_task_self_, vm_address_t(bitPattern: threads), vm_size_t(size))
+
+        result["threads"] = threadArray
+        result["threadCount"] = count
+        result["peakThreadCount"] = peakThreadCount
+        result["availability"] = "available"
+
+        return result
+    }
+
+    private func classifyThread(name: String, machThread: thread_act_t, mainThreadId: mach_port_t) -> String {
+        if machThread == mainThreadId { return "main" }
+        let lower = name.lowercased()
+        if lower.contains("jsthread") || lower.contains("hermes") || lower.contains("jsc") { return "js" }
+        if lower.contains("render") || lower.contains("coreanimation") { return "render" }
+        if lower.contains("network") || lower.contains("nsurlsession") || lower.contains("cfnetwork") { return "network" }
+        if lower.contains("worker") || lower.contains("dispatch") || lower.contains("pool") { return "worker" }
+        if lower.contains("db") || lower.contains("sqlite") || lower.contains("coredata") { return "db" }
+        if lower.contains("scalebun") || lower.contains("scalebun") { return "sdk_internal" }
+        return "unknown"
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - Render Collector (CADisplayLink)
+// ═══════════════════════════════════════════════════════════════════════════
+
+class IosRenderCollector {
+    private var displayLink: CADisplayLink?
+    private var lastTimestamp: CFTimeInterval = 0
+    private var totalFrames: Int = 0
+    private var slowFrames: Int = 0
+    private var frozenFrames: Int = 0
+    private var droppedFrames: Int = 0
+    private var maxFrameTimeMs: Double = 0
+    private var windowStartTime: CFTimeInterval = 0
+    private var framesInWindow: Int = 0
+
+    // Histogram: [0-8ms, 8-16ms, 16-33ms, 33-50ms, 50-100ms, 100-700ms, 700ms+]
+    private var histogram = [Int](repeating: 0, count: 7)
+
+    private let slowThresholdSec: CFTimeInterval = 1.0 / 60.0 // ~16.67ms
+    private let frozenThresholdSec: CFTimeInterval = 0.700
+
+    /// Start must be called on the main thread.
+    func start() {
+        guard displayLink == nil else { return }
+        displayLink = CADisplayLink(target: self, selector: #selector(onFrame(_:)))
+        displayLink?.add(to: .main, forMode: .common)
+        windowStartTime = CACurrentMediaTime()
+    }
+
+    func stop() {
+        displayLink?.invalidate()
+        displayLink = nil
+    }
+
+    @objc private func onFrame(_ link: CADisplayLink) {
+        let timestamp = link.timestamp
+
+        if lastTimestamp > 0 {
+            let duration = timestamp - lastTimestamp
+            let durationMs = duration * 1000.0
+
+            totalFrames += 1
+            framesInWindow += 1
+
+            if duration > frozenThresholdSec {
+                frozenFrames += 1
+                slowFrames += 1
+            } else if duration > slowThresholdSec {
+                slowFrames += 1
+            }
+
+            let expectedFrame = 1.0 / 60.0
+            let dropped = max(0, Int(duration / expectedFrame) - 1)
+            if dropped > 0 { droppedFrames += dropped }
+
+            if durationMs > maxFrameTimeMs { maxFrameTimeMs = durationMs }
+
+            // Histogram bucket
+            let bucket: Int
+            switch durationMs {
+            case ..<8: bucket = 0
+            case ..<16: bucket = 1
+            case ..<33: bucket = 2
+            case ..<50: bucket = 3
+            case ..<100: bucket = 4
+            case ..<700: bucket = 5
+            default: bucket = 6
+            }
+            histogram[bucket] += 1
+        }
+
+        lastTimestamp = timestamp
+    }
+
+    /// Collect must be called on the main thread (or via DispatchQueue.main.sync).
+    func collect() -> [String: Any] {
+        let now = CACurrentMediaTime()
+        let windowDuration = now - windowStartTime
+
+        let fps: Double
+        if windowDuration > 0 && framesInWindow > 0 {
+            fps = min(Double(framesInWindow) / windowDuration, 120.0)
+        } else {
+            fps = 0
+        }
+
+        let result: [String: Any] = [
+            "fps": round(fps * 10.0) / 10.0,
+            "totalFrames": totalFrames,
+            "slowFrames": slowFrames,
+            "frozenFrames": frozenFrames,
+            "droppedFrames": droppedFrames,
+            "maxFrameTimeMs": round(maxFrameTimeMs * 100.0) / 100.0,
+            "histogram": [
+                "0-8ms": histogram[0],
+                "8-16ms": histogram[1],
+                "16-33ms": histogram[2],
+                "33-50ms": histogram[3],
+                "50-100ms": histogram[4],
+                "100-700ms": histogram[5],
+                "700ms+": histogram[6]
+            ],
+            "availability": displayLink != nil ? "available" : "unavailable"
+        ]
+
+        // Reset window
+        windowStartTime = now
+        framesInWindow = 0
+
+        return result
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - Thermal Collector (ProcessInfo.thermalState)
+// ═══════════════════════════════════════════════════════════════════════════
+
+class IosThermalCollector {
+    private var currentThermalState: Int = 0
+
+    func start() {
+        // Observe thermal state changes
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(thermalStateChanged),
+            name: ProcessInfo.thermalStateDidChangeNotification,
+            object: nil
+        )
+        currentThermalState = mapThermalState(ProcessInfo.processInfo.thermalState)
+    }
+
+    func stop() {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc private func thermalStateChanged() {
+        currentThermalState = mapThermalState(ProcessInfo.processInfo.thermalState)
+    }
+
+    func collect() -> [String: Any] {
+        return [
+            "thermalState": currentThermalState,
+            "lowPowerMode": ProcessInfo.processInfo.isLowPowerModeEnabled,
+            "availability": "available"
+        ]
+    }
+
+    private func mapThermalState(_ state: ProcessInfo.ThermalState) -> Int {
+        switch state {
+        case .nominal: return 0
+        case .fair: return 1
+        case .serious: return 2
+        case .critical: return 3
+        @unknown default: return 0
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MARK: - Incident Detector
+// ═══════════════════════════════════════════════════════════════════════════
+
+class IosIncidentDetector {
+    var cpuSpikePercent: Double = 80.0
+    var memorySurgeBytesPerSec: Double = 10_485_760.0
+    var jankBurstFrameCount: Int = 5
+    var frozenFrameMs: Double = 700.0
+    var excessiveThreadCount: Int = 50
+
+    private var cpuSpikeConsecutive = 0
+    private let cpuSpikeSustainedCount = 3
+    private var lastIncidentTimestamp: TimeInterval = 0
+    private let minIncidentIntervalSec: TimeInterval = 5.0
+    private var incidentIdCounter: Int64 = 0
+
+    func updateThresholds(_ thresholds: [String: Any]) {
+        if let v = thresholds["cpuSpikePercent"] as? NSNumber { cpuSpikePercent = v.doubleValue }
+        if let v = thresholds["memorySurgeBytesPerSec"] as? NSNumber { memorySurgeBytesPerSec = v.doubleValue }
+        if let v = thresholds["jankBurstFrameCount"] as? NSNumber { jankBurstFrameCount = v.intValue }
+        if let v = thresholds["frozenFrameMs"] as? NSNumber { frozenFrameMs = v.doubleValue }
+        if let v = thresholds["excessiveThreadCount"] as? NSNumber { excessiveThreadCount = v.intValue }
+    }
+
+    func evaluate(
+        cpu: [String: Any]?,
+        memory: [String: Any]?,
+        render: [String: Any]?,
+        thermal: [String: Any]?,
+        memoryGrowthRate: Double?,
+        currentScreen: String
+    ) -> [[String: Any]] {
+        var incidents: [[String: Any]] = []
+        let now = Date().timeIntervalSince1970
+
+        guard now - lastIncidentTimestamp >= minIncidentIntervalSec else { return incidents }
+
+        // CPU spike
+        if let appCpu = cpu?["appCpuPercent"] as? Double {
+            if appCpu > cpuSpikePercent {
+                cpuSpikeConsecutive += 1
+                if cpuSpikeConsecutive >= cpuSpikeSustainedCount {
+                    incidents.append(buildIncident(
+                        type: "cpu_spike", title: "CPU Spike Detected",
+                        severity: appCpu > 95 ? "critical" : "warning",
+                        confidence: "high",
+                        cause: "App CPU at \(appCpu)% for \(cpuSpikeConsecutive) consecutive samples",
+                        description: "Sustained high CPU usage detected.",
+                        screen: currentScreen, timestamp: now
+                    ))
+                    cpuSpikeConsecutive = 0
+                    lastIncidentTimestamp = now
+                }
+            } else {
+                cpuSpikeConsecutive = 0
+            }
+        }
+
+        // Memory surge
+        if let rate = memoryGrowthRate, rate > memorySurgeBytesPerSec {
+            incidents.append(buildIncident(
+                type: "memory_surge", title: "Memory Surge Detected",
+                severity: rate > memorySurgeBytesPerSec * 2 ? "critical" : "warning",
+                confidence: "medium",
+                cause: "Memory growing at \(Int(rate / 1_048_576))MB/s",
+                description: "Rapid memory growth detected.",
+                screen: currentScreen, timestamp: now
+            ))
+            lastIncidentTimestamp = now
+        }
+
+        // Frozen frame
+        if let maxMs = render?["maxFrameTimeMs"] as? Double, maxMs > frozenFrameMs {
+            incidents.append(buildIncident(
+                type: "frozen_frame", title: "Frozen Frame Detected",
+                severity: maxMs > 2000 ? "critical" : "warning",
+                confidence: "high",
+                cause: "Frame took \(Int(maxMs))ms",
+                description: "A single frame caused visible UI freeze.",
+                screen: currentScreen, timestamp: now
+            ))
+            lastIncidentTimestamp = now
+        }
+
+        // Jank burst
+        if let slow = render?["slowFrames"] as? Int, slow >= jankBurstFrameCount {
+            incidents.append(buildIncident(
+                type: "jank_burst", title: "Jank Burst Detected",
+                severity: "warning", confidence: "medium",
+                cause: "\(slow) slow frames in sampling window",
+                description: "Multiple slow frames indicate UI jank.",
+                screen: currentScreen, timestamp: now
+            ))
+            lastIncidentTimestamp = now
+        }
+
+        // Thermal throttle
+        if let state = thermal?["thermalState"] as? Int, state >= 2 {
+            incidents.append(buildIncident(
+                type: "thermal_throttle",
+                title: state >= 3 ? "Critical Thermal State" : "Thermal Throttling",
+                severity: state >= 3 ? "critical" : "warning",
+                confidence: "high",
+                cause: "Thermal state: \(["nominal","fair","serious","critical"][min(state, 3)])",
+                description: "Device is thermally throttled, performance may be reduced.",
+                screen: currentScreen, timestamp: now
+            ))
+            lastIncidentTimestamp = now
+        }
+
+        return incidents
+    }
+
+    private func buildIncident(type: String, title: String, severity: String, confidence: String,
+                                cause: String, description: String, screen: String, timestamp: TimeInterval) -> [String: Any] {
+        incidentIdCounter += 1
+        return [
+            "id": "inc_\(incidentIdCounter)_\(Int(timestamp * 1000))",
+            "incidentType": type,
+            "title": title,
+            "severity": severity,
+            "confidence": confidence,
+            "likelyCause": cause,
+            "description": description,
+            "startTimestamp": timestamp * 1000,
+            "affectedScreens": screen.isEmpty ? [] : [screen]
+        ]
+    }
+}