@otakit/capacitor-updater 2.3.2 → 3.0.0

package/ios/Sources/UpdaterPlugin/DownloadRetry.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+struct DownloadHTTPError: Error, LocalizedError {
+  let status: Int
+  let retryAfter: String?
+  var errorDescription: String? { "Download failed with HTTP \(status)" }
+}
+
+/// Bounded retries for GET transport failures. Integrity and disk failures stay terminal.
+struct DownloadRetry {
+  static func isExpiredURLFailure(_ error: Error) -> Bool {
+    guard let http = error as? DownloadHTTPError else { return false }
+    return http.status == 403 || http.status == 410
+  }
+  var now: () -> Date = { Date() }
+  var random: () -> Double = { Double.random(in: 0..<1) }
+
+  func delay(for error: Error, attempt: Int) -> TimeInterval? {
+    guard attempt >= 1, attempt < 3, !Task.isCancelled else { return nil }
+    var serverDelay: TimeInterval?
+    if let http = error as? DownloadHTTPError {
+      guard [408, 425, 429, 500, 502, 503, 504].contains(http.status) else { return nil }
+      serverDelay = Self.retryAfter(http.retryAfter, now: now())
+      // Do not sleep indefinitely or retry earlier than a long server-requested delay.
+      if let serverDelay, serverDelay > 30 { return nil }
+    } else {
+      let failure = error as NSError
+      guard failure.domain == NSURLErrorDomain,
+            [NSURLErrorTimedOut, NSURLErrorCannotFindHost, NSURLErrorCannotConnectToHost,
+             NSURLErrorNetworkConnectionLost, NSURLErrorDNSLookupFailed,
+             NSURLErrorNotConnectedToInternet].contains(failure.code) else { return nil }
+    }
+    let backoff = pow(2, Double(attempt - 1)) * (0.5 + random())
+    return max(backoff, serverDelay ?? 0)
+  }
+
+  static func retryAfter(_ value: String?, now: Date) -> TimeInterval? {
+    guard let value else { return nil }
+    let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+    if !trimmed.isEmpty, trimmed.allSatisfy({ $0 >= "0" && $0 <= "9" }) {
+      return Double(trimmed) ?? .infinity
+    }
+    let formatter = DateFormatter()
+    formatter.locale = Locale(identifier: "en_US_POSIX")
+    formatter.timeZone = TimeZone(secondsFromGMT: 0)
+    formatter.dateFormat = "EEE, dd MMM yyyy HH:mm:ss zzz"
+    formatter.isLenient = false
+    guard let date = formatter.date(from: trimmed) else { return nil }
+    return max(0, date.timeIntervalSince(now))
+  }
+}

package/ios/Sources/UpdaterPlugin/Downloader.swift

@@ -2,9 +2,19 @@ import Foundation
 
 final class Downloader {
   private let allowInsecureUrls: Bool
-
-  init(allowInsecureUrls: Bool = false) {
+  private let retry: DownloadRetry
+  private let sleep: (TimeInterval) async throws -> Void
+
+  init(
+    allowInsecureUrls: Bool = false,
+    retry: DownloadRetry = DownloadRetry(),
+    sleep: @escaping (TimeInterval) async throws -> Void = {
+      try await Task.sleep(nanoseconds: UInt64($0 * 1_000_000_000))
+    }
+  ) {
     self.allowInsecureUrls = allowInsecureUrls
+    self.retry = retry
+    self.sleep = sleep
   }
 
   func download(
@@ -12,51 +22,85 @@ final class Downloader {
     progress: @escaping (Double, Int64, Int64) -> Void = { _, _, _ in }
   ) async throws -> URL {
     try ManifestClient.requireHTTPS(url: url, allowInsecure: allowInsecureUrls)
-    let delegate = DownloadDelegate(progressHandler: progress)
-    return try await delegate.start(from: url)
+    var attempt = 1
+    while true {
+      try Task.checkCancellation()
+      let delegate = DownloadDelegate(allowInsecureUrls: allowInsecureUrls, progressHandler: progress)
+      do {
+        let downloaded = try await delegate.start(from: url)
+        do { try Task.checkCancellation() }
+        catch { try? FileManager.default.removeItem(at: downloaded); throw error }
+        return downloaded
+      } catch {
+        guard let delay = retry.delay(for: error, attempt: attempt) else { throw error }
+        try await sleep(delay)
+        attempt += 1
+      }
+    }
   }
 }
 
 private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
   private var continuation: CheckedContinuation<URL, Error>?
   private var session: URLSession?
+  private let allowInsecureUrls: Bool
   private let progressHandler: (Double, Int64, Int64) -> Void
   private let stateLock = NSLock()
   private var isResolved = false
+  private var cancelled = false
 
-  init(progressHandler: @escaping (Double, Int64, Int64) -> Void) {
+  init(allowInsecureUrls: Bool, progressHandler: @escaping (Double, Int64, Int64) -> Void) {
+    self.allowInsecureUrls = allowInsecureUrls
     self.progressHandler = progressHandler
     super.init()
   }
 
   func start(from url: URL) async throws -> URL {
-    try await withCheckedThrowingContinuation { continuation in
-      self.continuation = continuation
-
-      let configuration = URLSessionConfiguration.default
-      let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
-      self.session = session
-      let task = session.downloadTask(with: url)
-      task.resume()
+    try await withTaskCancellationHandler {
+      try await withCheckedThrowingContinuation { continuation in
+        stateLock.lock()
+        if cancelled {
+          stateLock.unlock()
+          continuation.resume(throwing: CancellationError())
+          return
+        }
+        self.continuation = continuation
+        let configuration = URLSessionConfiguration.default
+        let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        self.session = session
+        var request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 60)
+        request.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
+        let task = session.downloadTask(with: request)
+        stateLock.unlock()
+        task.resume()
+      }
+    } onCancel: {
+      self.cancel()
     }
   }
 
-  private func resolve(_ result: Result<URL, Error>) {
+  private func cancel() {
+    stateLock.lock()
+    cancelled = true
+    stateLock.unlock()
+    resolve(.failure(CancellationError()))
+  }
+
+  @discardableResult
+  private func resolve(_ result: Result<URL, Error>) -> Bool {
     stateLock.lock()
     guard !isResolved, let continuation else {
       stateLock.unlock()
-      return
+      return false
     }
     isResolved = true
     self.continuation = nil
+    let session = self.session
+    self.session = nil
     stateLock.unlock()
-
-    switch result {
-    case let .success(url):
-      continuation.resume(returning: url)
-    case let .failure(error):
-      continuation.resume(throwing: error)
-    }
+    session?.invalidateAndCancel()
+    continuation.resume(with: result)
+    return true
   }
 
   func urlSession(
@@ -64,16 +108,12 @@ private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
     downloadTask: URLSessionDownloadTask,
     didFinishDownloadingTo location: URL
   ) {
-    // Check HTTP status before treating the file as a valid download
-    if let httpResponse = downloadTask.response as? HTTPURLResponse,
-       !(200..<300).contains(httpResponse.statusCode) {
-      resolve(.failure(NSError(
-        domain: "Downloader",
-        code: httpResponse.statusCode,
-        userInfo: [NSLocalizedDescriptionKey: "Download failed with HTTP \(httpResponse.statusCode)"]
-      )))
-      session.finishTasksAndInvalidate()
-      self.session = nil
+    guard let response = downloadTask.response as? HTTPURLResponse else {
+      resolve(.failure(URLError(.badServerResponse)))
+      return
+    }
+    if response.statusCode != 200 {
+      resolve(.failure(DownloadHTTPError(status: response.statusCode, retryAfter: response.value(forHTTPHeaderField: "Retry-After"))))
       return
     }
 
@@ -82,13 +122,26 @@ private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
 
     do {
       try FileManager.default.moveItem(at: location, to: temporaryZip)
-      resolve(.success(temporaryZip))
+      // Cancellation can win while the delegate moves the completed download.
+      if !resolve(.success(temporaryZip)) { try? FileManager.default.removeItem(at: temporaryZip) }
     } catch {
       resolve(.failure(error))
     }
+  }
 
-    session.finishTasksAndInvalidate()
-    self.session = nil
+  func urlSession(
+    _ session: URLSession, task: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void
+  ) {
+    do {
+      guard let url = request.url else { throw URLError(.badURL) }
+      try ManifestClient.requireHTTPS(url: url, allowInsecure: allowInsecureUrls)
+      completionHandler(request)
+    } catch {
+      completionHandler(nil)
+      resolve(.failure(error))
+    }
   }
 
   func urlSession(
@@ -111,10 +164,15 @@ private final class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
     didCompleteWithError error: Error?
   ) {
     if let error {
-      resolve(.failure(error))
+      let failure = error as NSError
+      if failure.domain == NSURLErrorDomain, failure.code == NSURLErrorCancelled {
+        resolve(.failure(CancellationError()))
+      } else {
+        resolve(.failure(error))
+      }
+    } else {
+      // A successful download normally resolves in didFinishDownloadingTo.
+      resolve(.failure(URLError(.badServerResponse)))
     }
-
-    session.finishTasksAndInvalidate()
-    self.session = nil
   }
 }

package/ios/Sources/UpdaterPlugin/EventOutbox.swift

@@ -0,0 +1,183 @@
+import Foundation
+
+/// Atomic, bounded persistence; retries preserve the exact original event body.
+final class EventOutbox {
+  static let limit = 256
+  static let ttl: TimeInterval = 7 * 24 * 60 * 60
+  struct Entry: Codable {
+    let id: String
+    let url: URL
+    let appId: String
+    let body: Data
+    let createdAt: TimeInterval
+    var attempts: Int
+    var nextAt: TimeInterval
+  }
+  private let file: URL
+  private let lock = NSLock()
+  private var entries: [Entry] = []
+
+  init(directory: URL) throws {
+    try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+    var directory = directory
+    var values = URLResourceValues()
+    values.isExcludedFromBackup = true
+    try directory.setResourceValues(values)
+    file = directory.appendingPathComponent("events.json")
+    if FileManager.default.fileExists(atPath: file.path) {
+      let size = try file.resourceValues(forKeys: [.fileSizeKey]).fileSize ?? 0
+      guard size <= 4 * 1024 * 1024 else { throw CocoaError(.fileReadTooLarge) }
+      let data = try Data(contentsOf: file)
+      do {
+        entries = try JSONDecoder().decode([Entry].self, from: data)
+        guard entries.count <= Self.limit else { throw CocoaError(.fileReadCorruptFile) }
+      } catch {
+        print("[OtaKit] Discarding unreadable event outbox")
+        try save([])
+      }
+    }
+  }
+
+  func enqueue(url: URL, appId: String, body: Data, now: TimeInterval) throws {
+    lock.lock(); defer { lock.unlock() }
+    guard body.count <= 8192,
+          let payload = try JSONSerialization.jsonObject(with: body) as? [String: Any],
+          let id = payload["eventId"] as? String else { throw CocoaError(.fileWriteInvalidFileName) }
+    var next = live(now)
+    guard !next.contains(where: { $0.id == id }) else { return }
+    while next.count >= Self.limit { next.removeFirst() }
+    next.append(Entry(id: id, url: url, appId: appId, body: body, createdAt: now, attempts: 0, nextAt: now))
+    try save(next)
+  }
+
+  func ready(now: TimeInterval) throws -> Entry? {
+    lock.lock(); defer { lock.unlock() }
+    let next = live(now)
+    if next.count != entries.count { try save(next) }
+    return entries.first { $0.nextAt <= now }
+  }
+
+  func wait(now: TimeInterval) -> TimeInterval? {
+    lock.lock(); defer { lock.unlock() }
+    return entries.map { max(0, min($0.nextAt, $0.createdAt + Self.ttl) - now) }.min()
+  }
+
+  func complete(id: String, status: Int, retryAfter: String?, now: TimeInterval, random: Double) throws {
+    lock.lock(); defer { lock.unlock() }
+    var next = live(now)
+    if let index = next.firstIndex(where: { $0.id == id }) {
+      if (200..<300).contains(status) || ((300..<500).contains(status) && ![408, 425, 429].contains(status)) {
+        next.remove(at: index)
+      } else {
+        next[index].attempts = min(next[index].attempts + 1, 20)
+        let backoff = min(3600, 5 * pow(2, Double(min(next[index].attempts - 1, 10)))) * (0.5 + random)
+        let serverDelay = DownloadRetry.retryAfter(retryAfter, now: Date(timeIntervalSince1970: now)) ?? 0
+        // Expiration is the upper bound; never retry before a longer server delay.
+        next[index].nextAt = min(now + max(backoff, serverDelay), next[index].createdAt + Self.ttl)
+      }
+    }
+    try save(next)
+  }
+
+  private func live(_ now: TimeInterval) -> [Entry] {
+    entries.filter { now < $0.createdAt + Self.ttl }
+  }
+
+  private func save(_ next: [Entry]) throws {
+    try JSONEncoder().encode(next).write(to: file, options: .atomic)
+    entries = next
+  }
+}
+
+/// Owns one serial delivery loop independently of any Capacitor bridge lifetime.
+final class EventDelivery: NSObject, URLSessionTaskDelegate {
+  private let worker = DispatchQueue(label: "OtaKit.events")
+  private let stateLock = NSLock()
+  private var outbox: EventOutbox?
+  private var scheduled: DispatchWorkItem?
+  private var sending = false
+  private let configuration: URLSessionConfiguration
+  private lazy var session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+
+  init(outbox: EventOutbox? = nil, configuration: URLSessionConfiguration = .ephemeral) {
+    self.outbox = outbox
+    self.configuration = configuration
+    super.init()
+  }
+
+  func resume() {
+    stateLock.lock()
+    if outbox == nil {
+      do {
+        let support = try FileManager.default.url(for: .applicationSupportDirectory, in: .userDomainMask,
+          appropriateFor: nil, create: true)
+        outbox = try EventOutbox(directory: support.appendingPathComponent("OtaKitEvents", isDirectory: true))
+      } catch { print("[OtaKit] Cannot open device event outbox") }
+    }
+    stateLock.unlock()
+    worker.async { self.schedule() }
+  }
+
+  func enqueue(url: URL, appId: String, body: Data) {
+    stateLock.lock()
+    let outbox = self.outbox
+    stateLock.unlock()
+    do {
+      guard let outbox else { throw CocoaError(.fileWriteUnknown) }
+      try outbox.enqueue(url: url, appId: appId, body: body, now: Date().timeIntervalSince1970)
+      worker.async { self.schedule() }
+    } catch { print("[OtaKit] Cannot persist device event") }
+  }
+
+  private func schedule(minimumDelay: TimeInterval = 0) {
+    guard !sending else { return }
+    scheduled?.cancel()
+    stateLock.lock(); let outbox = self.outbox; stateLock.unlock()
+    guard let delay = outbox?.wait(now: Date().timeIntervalSince1970) else { scheduled = nil; return }
+    let item = DispatchWorkItem { self.drain() }
+    scheduled = item
+    worker.asyncAfter(deadline: .now() + max(minimumDelay, delay), execute: item)
+  }
+
+  private func drain() {
+    guard !sending else { return }
+    scheduled?.cancel(); scheduled = nil
+    stateLock.lock(); let outbox = self.outbox; stateLock.unlock()
+    guard let outbox else { return }
+    do {
+      guard let entry = try outbox.ready(now: Date().timeIntervalSince1970) else { schedule(); return }
+      sending = true
+      var request = URLRequest(url: entry.url)
+      request.httpMethod = "POST"
+      request.setValue(entry.appId, forHTTPHeaderField: "X-App-Id")
+      request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+      request.httpBody = entry.body
+      request.timeoutInterval = 10
+      session.dataTask(with: request) { _, response, error in
+        self.worker.async {
+          let http = response as? HTTPURLResponse
+          var storageFailed = false
+          do {
+            try outbox.complete(id: entry.id, status: error == nil ? (http?.statusCode ?? 0) : 0,
+              retryAfter: http?.value(forHTTPHeaderField: "Retry-After"),
+              now: Date().timeIntervalSince1970, random: Double.random(in: 0..<1))
+          } catch {
+            storageFailed = true
+            print("[OtaKit] Cannot persist device event delivery state")
+          }
+          self.sending = false
+          self.schedule(minimumDelay: storageFailed ? 60 : 0)
+        }
+      }.resume()
+    } catch {
+      print("[OtaKit] Cannot read device event outbox")
+      schedule(minimumDelay: 60)
+    }
+  }
+
+  func urlSession(_ session: URLSession, task: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void) {
+    completionHandler(nil)
+  }
+}

package/ios/Sources/UpdaterPlugin/ForegroundDeadline.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+/// Owned by the main thread. Only foreground time consumes the readiness budget.
+final class ForegroundDeadline {
+  typealias Scheduler = (TimeInterval, @escaping () -> Void) -> () -> Void
+  private let now: () -> TimeInterval
+  private let schedule: Scheduler
+  private var foreground = false
+  private var remaining: TimeInterval = 0
+  private var startedAt: TimeInterval = 0
+  private var generation = 0
+  private var action: (() -> Void)?
+  private var cancelScheduled: (() -> Void)?
+  private var observations: [(NotificationCenter, NSObjectProtocol)] = []
+
+  init(
+    now: @escaping () -> TimeInterval = { ProcessInfo.processInfo.systemUptime },
+    schedule: @escaping Scheduler = { delay, callback in
+      let item = DispatchWorkItem(block: callback)
+      DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: item)
+      return { item.cancel() }
+    }
+  ) {
+    self.now = now
+    self.schedule = schedule
+  }
+
+  func observe(
+    center: NotificationCenter, active: Notification.Name, inactive: Notification.Name,
+    initiallyActive: Bool
+  ) {
+    setForeground(initiallyActive)
+    observations.append((center, center.addObserver(forName: active, object: nil, queue: .main) { [weak self] _ in
+      self?.setForeground(true)
+    }))
+    observations.append((center, center.addObserver(forName: inactive, object: nil, queue: .main) { [weak self] _ in
+      self?.setForeground(false)
+    }))
+  }
+
+  func start(timeout: TimeInterval, action: @escaping () -> Void) {
+    cancel()
+    remaining = max(0, timeout)
+    self.action = action
+    arm()
+  }
+
+  func setForeground(_ value: Bool) {
+    guard value != foreground else { return }
+    if foreground, action != nil {
+      remaining = max(0, remaining - max(0, now() - startedAt))
+    }
+    disarm()
+    foreground = value
+    arm()
+  }
+
+  func cancel() {
+    disarm()
+    action = nil
+    remaining = 0
+  }
+
+  private func disarm() {
+    generation += 1
+    cancelScheduled?()
+    cancelScheduled = nil
+  }
+
+  private func arm() {
+    guard foreground, action != nil else { return }
+    startedAt = now()
+    generation += 1
+    let expectedGeneration = generation
+    cancelScheduled = schedule(remaining) { [weak self] in
+      self?.fire(expectedGeneration: expectedGeneration)
+    }
+  }
+
+  private func fire(expectedGeneration: Int) {
+    guard generation == expectedGeneration, foreground, let action else { return }
+    remaining = max(0, remaining - max(0, now() - startedAt))
+    cancelScheduled = nil
+    if remaining > 0 { arm(); return }
+    self.action = nil
+    generation += 1
+    action()
+  }
+
+  deinit {
+    cancelScheduled?()
+    for (center, observation) in observations { center.removeObserver(observation) }
+  }
+}

package/ios/Sources/UpdaterPlugin/HashUtils.swift

@@ -30,4 +30,20 @@ enum HashUtils {
     let actual = try sha256(fileURL: fileURL)
     return actual.lowercased() == expectedSha256.lowercased()
   }
+
+  static func verifyDownload(fileURL: URL, expectedSha256: String, expectedBytes: Int?, kind: String) throws {
+    let actual = try sha256(fileURL: fileURL)
+    let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
+    guard let size = attributes[.size] as? NSNumber else { throw HashUtilsError.couldNotOpenFile }
+    let received = size.int64Value
+    let hashMatches = actual.caseInsensitiveCompare(expectedSha256) == .orderedSame
+    let sizeMatches = expectedBytes.map { Int64($0) == received } ?? true
+    guard hashMatches && sizeMatches else {
+      let safeExpected = expectedSha256.range(of: "^[a-fA-F0-9]{64}$", options: .regularExpression) != nil
+        ? expectedSha256.lowercased() : "invalid"
+      let reason = hashMatches ? "size mismatch" : "hash mismatch"
+      throw NSError(domain: "OtaKit", code: 1, userInfo: [NSLocalizedDescriptionKey:
+        "Downloaded \(kind) \(reason); expectedSha256=\(safeExpected); actualSha256=\(actual); expectedBytes=\(expectedBytes ?? -1); receivedBytes=\(received)"])
+    }
+  }
 }

package/ios/Sources/UpdaterPlugin/ManifestClient.swift

@@ -45,6 +45,7 @@ enum ManifestClientError: Error {
   case invalidURL
   case invalidResponse
   case requestFailed(String)
+  case httpStatus(Int)
   case insecureURL(String)
 }
 
@@ -107,10 +108,7 @@ enum ManifestClient {
     }
 
     guard httpResponse.statusCode == 200 else {
-      let body = String(data: data, encoding: .utf8) ?? "unknown"
-      throw ManifestClientError.requestFailed(
-        "HTTP \(httpResponse.statusCode): \(body)"
-      )
+      throw ManifestClientError.httpStatus(httpResponse.statusCode)
     }
 
     guard

package/ios/Sources/UpdaterPlugin/ManifestKeyConfig.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+/// Empty means intentionally unconfigured; malformed explicit settings must never return empty.
+enum ManifestKeyConfig {
+  static func parse(_ config: [String: Any]) -> [(kid: String, key: Data)] {
+    guard let rawValue = config["manifestKeys"] else { return [] }
+    guard let entries = rawValue as? [[String: String]] else { return invalid() }
+    let keys: [(kid: String, key: Data)] = entries.compactMap { entry in
+      guard let kid = entry["kid"], let encoded = entry["key"],
+            let data = Data(base64Encoded: encoded) else { return nil }
+      return (kid: kid, key: data)
+    }
+    return keys.isEmpty && !entries.isEmpty ? invalid() : keys
+  }
+
+  private static func invalid() -> [(kid: String, key: Data)] {
+    print("[OtaKit] ERROR: Invalid manifestKeys configuration. Manifest verification will reject all updates.")
+    return [(kid: "_invalid_", key: Data())]
+  }
+}

package/ios/Sources/UpdaterPlugin/ManifestVerifier.swift

@@ -51,7 +51,13 @@ enum ManifestVerifier {
       iat: signature.iat,
       exp: signature.exp
     )
-    try verifyPayload(payload, signature: signature, trustedKeys: trustedKeys)
+    do {
+      try verifyPayload(payload, signature: signature, trustedKeys: trustedKeys)
+    } catch let error as ManifestVerifierError {
+      throw error
+    } catch {
+      throw ManifestVerifierError.invalidSignature
+    }
   }
 
   private static func verifyPayload(

package/ios/Sources/UpdaterPlugin/SDKVersion.swift

@@ -0,0 +1,4 @@
+// Generated from package.json by scripts/generate-native-sdk-version.mjs.
+enum SDKVersion {
+  static let value = "3.0.0"
+}

package/ios/Sources/UpdaterPlugin/UpdateOwner.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+/// Checked on the main thread together with state publication and activation.
+final class UpdateOwner {
+  private let isAvailable: () -> Bool
+  init(isAvailable: @escaping () -> Bool) { self.isAvailable = isAvailable }
+
+  func run<T>(_ action: () throws -> T) throws -> T {
+    guard isAvailable() else { throw CancellationError() }
+    return try action()
+  }
+}