The Termination That Never Shows Up as a Crash — Reading JetsamEvent in Rork Apps

import os
 
/// How many more MB this process can allocate
func availableMemoryMB() -> Double {
    Double(os_proc_available_memory()) / 1_048_576.0
}
 
/// Called right after launch, this yields "limit minus current usage"
func logMemoryBudget() {
    var info = mach_task_basic_info()
    var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
    let kr = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
        }
    }
    guard kr == KERN_SUCCESS else { return }
    let usedMB  = Double(info.resident_size) / 1_048_576.0
    let availMB = availableMemoryMB()
    print(String(format: "used %.0f MB / avail %.0f MB / limit ≈ %.0f MB",
                 usedMB, availMB, usedMB + availMB))
}

import UIKit
 
final class BudgetedImageCache {
    static let shared = BudgetedImageCache()
    private let cache = NSCache<NSString, UIImage>()
 
    private init() {
        applyBudget()
        NotificationCenter.default.addObserver(
            forName: UIApplication.didReceiveMemoryWarningNotification,
            object: nil, queue: .main
        ) { [weak self] _ in
            // halve on warning; purging everything invites a re-decode spike on scroll-back
            self?.cache.totalCostLimit /= 2
        }
    }
 
    /// Budget the cache at 25% of remaining memory, measured at launch
    private func applyBudget() {
        let availableBytes = os_proc_available_memory()
        cache.totalCostLimit = Int(Double(availableBytes) * 0.25)
    }
 
    func store(_ image: UIImage, for key: String) {
        // cost is pixels × 4 bytes (RGBA), not the file size on disk
        let cost = Int(image.size.width * image.scale
                     * image.size.height * image.scale * 4)
        cache.setObject(image, forKey: key as NSString, cost: cost)
    }
 
    func image(for key: String) -> UIImage? {
        cache.object(forKey: key as NSString)
    }
}

import { NativeModules, Platform } from 'react-native';
 
/** assumes a small native bridge exposing os_proc_available_memory() */
async function cacheBudgetBytes(): Promise<number> {
  if (Platform.OS !== 'ios') return 128 * 1024 * 1024;
  const avail: number = await NativeModules.MemoryBudget.availableBytes();
  return Math.floor(avail * 0.25);
}
 
export async function configureImageCache() {
  const budget = await cacheBudgetBytes();
  // divide the budget by an average decoded size (12 MB here) to get a retention count
  const maxImages = Math.max(8, Math.floor(budget / (12 * 1024 * 1024)));
  return { maxImages, budgetMB: Math.round(budget / 1048576) };
}

import ImageIO
import UIKit
 
func downsample(url: URL, to pointSize: CGSize, scale: CGFloat) -> UIImage? {
    let srcOptions = [kCGImageSourceShouldCache: false] as CFDictionary
    guard let src = CGImageSourceCreateWithURL(url as CFURL, srcOptions) else { return nil }
 
    let maxPixel = max(pointSize.width, pointSize.height) * scale
    let options = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceCreateThumbnailWithTransform: true,
        kCGImageSourceThumbnailMaxPixelSize: maxPixel,
    ] as CFDictionary
 
    guard let cg = CGImageSourceCreateThumbnailAtIndex(src, 0, options) else { return nil }
    return UIImage(cgImage: cg, scale: scale, orientation: .up)
}

actor DecodeLimiter {
    private var running = 0
    private var waiters: [CheckedContinuation<Void, Never>] = []
    private let maxConcurrent: Int
 
    init(maxConcurrent: Int = 3) { self.maxConcurrent = maxConcurrent }
 
    func acquire() async {
        if running < maxConcurrent { running += 1; return }
        await withCheckedContinuation { waiters.append($0) }
        running += 1
    }
 
    func release() {
        running -= 1
        if let next = waiters.first { waiters.removeFirst(); next.resume() }
    }
}

import MetricKit
 
final class MemoryExitObserver: NSObject, MXMetricManagerSubscriber {
    static let shared = MemoryExitObserver()
 
    func start() { MXMetricManager.shared.add(self) }
 
    func didReceive(_ payloads: [MXMetricPayload]) {
        for p in payloads {
            guard let exit = p.applicationExitMetrics?.foregroundExitData else { continue }
            let memKills = exit.cumulativeMemoryResourceLimitExitCount
            let normal   = exit.cumulativeNormalAppExitCount
            guard memKills > 0 else { continue }
            // send to your own logging; the absolute count means little without a ratio
            let rate = Double(memKills) / Double(max(normal + memKills, 1)) * 100
            print(String(format: "foreground memory kills: %d (%.2f%%)", memKills, rate))
        }
    }
}