@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/UserNotifications/Content.swift

@@ -0,0 +1,370 @@
+// UserNotifications' value types: what a notification says, when it fires,
+// and what the viewer allowed. Shapes and names follow Apple's framework;
+// the center that schedules and shows them is NotificationCenter.swift.
+
+import Foundation
+
+// MARK: Authorization
+
+/// What an app asks permission for. The browser has one permission for all of
+/// it; the options are recorded and otherwise ignored.
+public struct UNAuthorizationOptions: OptionSet, Sendable, Hashable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+
+    public static let badge = UNAuthorizationOptions(rawValue: 1 << 0)
+    public static let sound = UNAuthorizationOptions(rawValue: 1 << 1)
+    public static let alert = UNAuthorizationOptions(rawValue: 1 << 2)
+    public static let carPlay = UNAuthorizationOptions(rawValue: 1 << 3)
+    public static let criticalAlert = UNAuthorizationOptions(rawValue: 1 << 4)
+    public static let providesAppNotificationSettings = UNAuthorizationOptions(rawValue: 1 << 5)
+    public static let provisional = UNAuthorizationOptions(rawValue: 1 << 6)
+}
+
+/// The browser's `Notification.permission`: `default` is `.notDetermined`,
+/// `granted` `.authorized`, `denied` (or no Notification API) `.denied`.
+public enum UNAuthorizationStatus: Int, Sendable {
+    case notDetermined = 0
+    case denied = 1
+    case authorized = 2
+    case provisional = 3
+    case ephemeral = 4
+}
+
+public enum UNNotificationSetting: Int, Sendable {
+    case notSupported = 0
+    case disabled = 1
+    case enabled = 2
+}
+
+public enum UNAlertStyle: Int, Sendable {
+    case none = 0
+    case banner = 1
+    case alert = 2
+}
+
+public enum UNShowPreviewsSetting: Int, Sendable {
+    case always = 0
+    case whenAuthenticated = 1
+    case never = 2
+}
+
+/// What `getNotificationSettings` reports. Every per-kind setting follows the
+/// one browser permission: enabled when authorized, else disabled.
+public final class UNNotificationSettings: NSObject, @unchecked Sendable {
+    public let authorizationStatus: UNAuthorizationStatus
+    public let soundSetting: UNNotificationSetting
+    public let badgeSetting: UNNotificationSetting
+    public let alertSetting: UNNotificationSetting
+    public let notificationCenterSetting: UNNotificationSetting
+    public let lockScreenSetting: UNNotificationSetting
+    public let carPlaySetting: UNNotificationSetting
+    public let criticalAlertSetting: UNNotificationSetting
+    public let timeSensitiveSetting: UNNotificationSetting
+    public let scheduledDeliverySetting: UNNotificationSetting
+    public let directMessagesSetting: UNNotificationSetting
+    public let announcementSetting: UNNotificationSetting
+    public let alertStyle: UNAlertStyle
+    public let showPreviewsSetting: UNShowPreviewsSetting
+    public let providesAppNotificationSettings: Bool
+
+    init(authorizationStatus: UNAuthorizationStatus) {
+        self.authorizationStatus = authorizationStatus
+        let shown: UNNotificationSetting = authorizationStatus == .authorized ? .enabled : .disabled
+        soundSetting = shown
+        badgeSetting = shown
+        alertSetting = shown
+        notificationCenterSetting = shown
+        lockScreenSetting = shown
+        carPlaySetting = .notSupported
+        criticalAlertSetting = .notSupported
+        timeSensitiveSetting = .notSupported
+        scheduledDeliverySetting = .notSupported
+        directMessagesSetting = .notSupported
+        announcementSetting = .notSupported
+        alertStyle = authorizationStatus == .authorized ? .banner : .none
+        showPreviewsSetting = .always
+        providesAppNotificationSettings = false
+        super.init()
+    }
+}
+
+/// Errors the center reports. In the browser: `.notificationsNotAllowed` when
+/// the page has no Notification API (an iPhone browser tab that is not on the
+/// Home Screen, for one).
+public struct UNError: Error, Hashable, Sendable, CustomStringConvertible {
+    public enum Code: Int, Sendable {
+        case notificationsNotAllowed = 1
+        case attachmentInvalidURL = 100
+        case attachmentUnrecognizedType = 101
+        case attachmentInvalidFileSize = 102
+        case attachmentNotInDataStore = 103
+        case attachmentMoveIntoDataStoreFailed = 104
+        case attachmentCorrupt = 105
+        case notificationInvalidNoDate = 1400
+        case notificationInvalidNoContent = 1401
+        case contentProvidingObjectNotAllowed = 1500
+        case contentProvidingInvalid = 1501
+        case badgeInputInvalid = 1600
+    }
+
+    public let code: Code
+
+    public init(_ code: Code) { self.code = code }
+
+    public static let notificationsNotAllowed = Code.notificationsNotAllowed
+    public static let notificationInvalidNoDate = Code.notificationInvalidNoDate
+    public static let notificationInvalidNoContent = Code.notificationInvalidNoContent
+
+    public var description: String {
+        switch code {
+        case .notificationsNotAllowed: "Notifications are not allowed for this application"
+        default: "UNErrorDomain error \(code.rawValue)"
+        }
+    }
+
+    public var localizedDescription: String { description }
+}
+
+// MARK: Content
+
+public struct UNNotificationSoundName: RawRepresentable, Hashable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+    public init(_ rawValue: String) { self.rawValue = rawValue }
+}
+
+/// A notification's sound. The browser plays its own, or none: a notification
+/// without a sound is shown `silent`.
+public final class UNNotificationSound: NSObject, @unchecked Sendable {
+    public let name: UNNotificationSoundName?
+    let critical: Bool
+
+    init(name: UNNotificationSoundName?, critical: Bool = false) {
+        self.name = name
+        self.critical = critical
+        super.init()
+    }
+
+    public class var `default`: UNNotificationSound { UNNotificationSound(name: nil) }
+    public class var defaultCritical: UNNotificationSound { UNNotificationSound(name: nil, critical: true) }
+    public class var defaultRingtone: UNNotificationSound { UNNotificationSound(name: nil) }
+
+    public class func defaultCriticalSound(withAudioVolume volume: Float) -> UNNotificationSound { .defaultCritical }
+    public class func soundNamed(_ name: UNNotificationSoundName) -> UNNotificationSound { UNNotificationSound(name: name) }
+    public class func criticalSoundNamed(_ name: UNNotificationSoundName) -> UNNotificationSound { UNNotificationSound(name: name, critical: true) }
+    public class func criticalSoundNamed(_ name: UNNotificationSoundName, withAudioVolume volume: Float) -> UNNotificationSound {
+        UNNotificationSound(name: name, critical: true)
+    }
+}
+
+public enum UNNotificationInterruptionLevel: UInt, Sendable {
+    case passive = 0
+    case active = 1
+    case timeSensitive = 2
+    case critical = 3
+}
+
+/// What a notification says. Immutable; `UNMutableNotificationContent` is the
+/// one apps fill in. The browser shows the title, and the subtitle and body
+/// as the notification's text, one line each.
+open class UNNotificationContent: NSObject, NSCopying, NSMutableCopying, @unchecked Sendable {
+    fileprivate var storedTitle = ""
+    fileprivate var storedSubtitle = ""
+    fileprivate var storedBody = ""
+    fileprivate var storedBadge: NSNumber?
+    fileprivate var storedSound: UNNotificationSound?
+    fileprivate var storedUserInfo: [AnyHashable: Any] = [:]
+    fileprivate var storedCategoryIdentifier = ""
+    fileprivate var storedThreadIdentifier = ""
+    fileprivate var storedLaunchImageName = ""
+    fileprivate var storedTargetContentIdentifier: String?
+    fileprivate var storedInterruptionLevel = UNNotificationInterruptionLevel.active
+    fileprivate var storedRelevanceScore = 0.0
+    fileprivate var storedFilterCriteria: String?
+
+    open var title: String { storedTitle }
+    open var subtitle: String { storedSubtitle }
+    open var body: String { storedBody }
+    open var badge: NSNumber? { storedBadge }
+    open var sound: UNNotificationSound? { storedSound }
+    open var userInfo: [AnyHashable: Any] { storedUserInfo }
+    open var categoryIdentifier: String { storedCategoryIdentifier }
+    open var threadIdentifier: String { storedThreadIdentifier }
+    open var launchImageName: String { storedLaunchImageName }
+    open var targetContentIdentifier: String? { storedTargetContentIdentifier }
+    open var interruptionLevel: UNNotificationInterruptionLevel { storedInterruptionLevel }
+    open var relevanceScore: Double { storedRelevanceScore }
+    open var filterCriteria: String? { storedFilterCriteria }
+
+    public override init() {
+        super.init()
+    }
+
+    fileprivate func fill(from other: UNNotificationContent) {
+        storedTitle = other.storedTitle
+        storedSubtitle = other.storedSubtitle
+        storedBody = other.storedBody
+        storedBadge = other.storedBadge
+        storedSound = other.storedSound
+        storedUserInfo = other.storedUserInfo
+        storedCategoryIdentifier = other.storedCategoryIdentifier
+        storedThreadIdentifier = other.storedThreadIdentifier
+        storedLaunchImageName = other.storedLaunchImageName
+        storedTargetContentIdentifier = other.storedTargetContentIdentifier
+        storedInterruptionLevel = other.storedInterruptionLevel
+        storedRelevanceScore = other.storedRelevanceScore
+        storedFilterCriteria = other.storedFilterCriteria
+    }
+
+    /// An immutable copy.
+    open func copy(with zone: NSZone? = nil) -> Any {
+        let copy = UNNotificationContent()
+        copy.fill(from: self)
+        return copy
+    }
+
+    /// A `UNMutableNotificationContent` with the same values.
+    open func mutableCopy(with zone: NSZone? = nil) -> Any {
+        let copy = UNMutableNotificationContent()
+        copy.fill(from: self)
+        return copy
+    }
+}
+
+open class UNMutableNotificationContent: UNNotificationContent, @unchecked Sendable {
+    open override var title: String { get { storedTitle } set { storedTitle = newValue } }
+    open override var subtitle: String { get { storedSubtitle } set { storedSubtitle = newValue } }
+    open override var body: String { get { storedBody } set { storedBody = newValue } }
+    /// Sets the app badge (`navigator.setAppBadge`, where the browser has it) when delivered; 0 clears it.
+    open override var badge: NSNumber? { get { storedBadge } set { storedBadge = newValue } }
+    open override var sound: UNNotificationSound? { get { storedSound } set { storedSound = newValue } }
+    open override var userInfo: [AnyHashable: Any] { get { storedUserInfo } set { storedUserInfo = newValue } }
+    open override var categoryIdentifier: String { get { storedCategoryIdentifier } set { storedCategoryIdentifier = newValue } }
+    open override var threadIdentifier: String { get { storedThreadIdentifier } set { storedThreadIdentifier = newValue } }
+    open override var launchImageName: String { get { storedLaunchImageName } set { storedLaunchImageName = newValue } }
+    open override var targetContentIdentifier: String? { get { storedTargetContentIdentifier } set { storedTargetContentIdentifier = newValue } }
+    open override var interruptionLevel: UNNotificationInterruptionLevel { get { storedInterruptionLevel } set { storedInterruptionLevel = newValue } }
+    open override var relevanceScore: Double { get { storedRelevanceScore } set { storedRelevanceScore = newValue } }
+    open override var filterCriteria: String? { get { storedFilterCriteria } set { storedFilterCriteria = newValue } }
+
+    public override init() {
+        super.init()
+    }
+}
+
+// MARK: Triggers
+
+/// When a request is delivered. A request without a trigger is delivered at once.
+open class UNNotificationTrigger: NSObject, @unchecked Sendable {
+    public let repeats: Bool
+
+    init(repeats: Bool) {
+        self.repeats = repeats
+        super.init()
+    }
+
+    /// The first delivery after `date` (the scheduling uses this; the
+    /// subclasses' `nextTriggerDate()` asks it about now).
+    func nextFireDate(after date: Date) -> Date? { nil }
+}
+
+/// Fires `timeInterval` seconds after the request is added, and every
+/// `timeInterval` seconds after that when it repeats.
+public final class UNTimeIntervalNotificationTrigger: UNNotificationTrigger, @unchecked Sendable {
+    public let timeInterval: TimeInterval
+
+    /// As on iOS, the interval must be positive, and at least 60 seconds when
+    /// the trigger repeats.
+    public init(timeInterval: TimeInterval, repeats: Bool) {
+        precondition(timeInterval > 0, "time interval must be greater than 0")
+        precondition(!repeats || timeInterval >= 60, "time interval must be at least 60 if repeating")
+        self.timeInterval = timeInterval
+        super.init(repeats: repeats)
+    }
+
+    public func nextTriggerDate() -> Date? { nextFireDate(after: Date()) }
+
+    override func nextFireDate(after date: Date) -> Date? { date.addingTimeInterval(timeInterval) }
+}
+
+/// Fires at the next date matching `dateComponents` (in their calendar and
+/// time zone, else the current ones), and at each match after that when it
+/// repeats: `hour = 9` is every day at 9:00, `weekday = 2, hour = 9` every
+/// Monday.
+public final class UNCalendarNotificationTrigger: UNNotificationTrigger, @unchecked Sendable {
+    public let dateComponents: DateComponents
+
+    public init(dateMatching dateComponents: DateComponents, repeats: Bool) {
+        self.dateComponents = dateComponents
+        super.init(repeats: repeats)
+    }
+
+    public func nextTriggerDate() -> Date? { nextFireDate(after: Date()) }
+
+    override func nextFireDate(after date: Date) -> Date? {
+        var calendar = dateComponents.calendar ?? Calendar.current
+        if let timeZone = dateComponents.timeZone { calendar.timeZone = timeZone }
+        var matching = dateComponents
+        matching.calendar = nil
+        matching.timeZone = nil
+        return calendar.nextDate(after: date, matching: matching, matchingPolicy: .nextTime)
+    }
+}
+
+// MARK: Requests
+
+public final class UNNotificationRequest: NSObject, @unchecked Sendable {
+    public let identifier: String
+    public let content: UNNotificationContent
+    public let trigger: UNNotificationTrigger?
+
+    /// `content` is copied, as on iOS: changing it afterwards changes nothing.
+    public init(identifier: String, content: UNNotificationContent, trigger: UNNotificationTrigger?) {
+        self.identifier = identifier
+        self.content = content.copy() as! UNNotificationContent
+        self.trigger = trigger
+        super.init()
+    }
+}
+
+/// A delivered notification.
+public final class UNNotification: NSObject, @unchecked Sendable {
+    public let date: Date
+    public let request: UNNotificationRequest
+
+    init(date: Date, request: UNNotificationRequest) {
+        self.date = date
+        self.request = request
+        super.init()
+    }
+}
+
+/// How to present a notification while the app is open, as a delegate's
+/// `willPresent` answers.
+public struct UNNotificationPresentationOptions: OptionSet, Sendable, Hashable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+
+    public static let badge = UNNotificationPresentationOptions(rawValue: 1 << 0)
+    public static let sound = UNNotificationPresentationOptions(rawValue: 1 << 1)
+    public static let alert = UNNotificationPresentationOptions(rawValue: 1 << 2)
+    public static let list = UNNotificationPresentationOptions(rawValue: 1 << 3)
+    public static let banner = UNNotificationPresentationOptions(rawValue: 1 << 4)
+}
+
+/// The viewer's answer to a notification. The browser never reports one (a
+/// click on a notification focuses the page), so `didReceive` is not called.
+public final class UNNotificationResponse: NSObject, @unchecked Sendable {
+    public let notification: UNNotification
+    public let actionIdentifier: String
+
+    init(notification: UNNotification, actionIdentifier: String) {
+        self.notification = notification
+        self.actionIdentifier = actionIdentifier
+        super.init()
+    }
+}
+
+public let UNNotificationDefaultActionIdentifier = "com.apple.UNNotificationDefaultActionIdentifier"
+public let UNNotificationDismissActionIdentifier = "com.apple.UNNotificationDismissActionIdentifier"

package/Sources/UserNotifications/NotificationCenter.swift

@@ -0,0 +1,309 @@
+// UserNotifications over the browser's Notification API. The center keeps
+// the pending requests and schedules each with a timer of its own (the
+// executor's, which the page drives with `setTimeout`); when one fires, the
+// page shows it with `new Notification(…)`. Permission is the page's
+// `Notification.permission`, asked for with `Notification.requestPermission()`.
+//
+// Every exchange with the page is a host request of kind `notification`
+// (docs/ops-protocol.md, "Notifications"). Timers only run while the page is
+// open: a notification scheduled for tomorrow is shown only if the app is
+// still open tomorrow (in a background tab, a few seconds late at most).
+// Headless runs answer deterministically: permission is "default" until the
+// app asks, then "granted", and deliveries happen on the virtual clock.
+
+import Foundation
+import SwiftUI
+
+public protocol UNUserNotificationCenterDelegate: AnyObject {
+    /// Asked before a notification is shown while the app is open. In the
+    /// browser the app is open whenever a notification can fire, so a center
+    /// without a delegate shows every notification (iOS would show none).
+    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification,
+                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void)
+    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions
+    /// Never called in the browser: the page gets no answer from a notification.
+    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse,
+                                withCompletionHandler completionHandler: @escaping () -> Void)
+    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async
+    func userNotificationCenter(_ center: UNUserNotificationCenter, openSettingsFor notification: UNNotification?)
+}
+
+extension UNUserNotificationCenterDelegate {
+    public func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification,
+                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        completionHandler(UNUserNotificationCenter.showEverything)
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
+        await withCheckedContinuation { continuation in
+            userNotificationCenter(center, willPresent: notification) { continuation.resume(returning: $0) }
+        }
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse,
+                                       withCompletionHandler completionHandler: @escaping () -> Void) {
+        completionHandler()
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async {}
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter, openSettingsFor notification: UNNotification?) {}
+}
+
+open class UNUserNotificationCenter: NSObject, @unchecked Sendable {
+    /// Sends one `notification` request to the page; `headless` is the answer
+    /// a headless run gives instead. Tests substitute it.
+    typealias Transport = @MainActor @Sendable (_ params: _JSON, _ headless: _JSON) async throws -> _JSON
+
+    private static let shared = UNUserNotificationCenter(transport: { params, headless in
+        try await _Runtime.shared._hostRequest(kind: "notification", params: params, headless: headless)
+    })
+
+    /// The app's notification center.
+    open class func current() -> UNUserNotificationCenter { shared }
+
+    weak open var delegate: (any UNUserNotificationCenterDelegate)?
+
+    open var supportsContentExtensions: Bool { false }
+
+    static let showEverything: UNNotificationPresentationOptions = [.banner, .list, .sound, .badge]
+
+    /// Timers sleep at most a day at a time: the page's `setTimeout` cannot
+    /// wait longer than 24.8 days.
+    static let longestSleep: TimeInterval = 86_400
+
+    private struct Scheduled {
+        let request: UNNotificationRequest
+        /// Nil when the trigger never matches again; the request stays pending, as on iOS.
+        let fireDate: Date?
+        let token: Int
+        let timer: Task<Void, Never>?
+    }
+
+    private let transport: Transport
+    private let lock = NSLock()
+    private var pending: [Scheduled] = []
+    private var delivered: [UNNotification] = []
+    private var nextToken = 1
+    /// The last permission the page reported, and what a headless run answers.
+    private var knownPermission = "default"
+
+    init(transport: @escaping Transport) {
+        self.transport = transport
+        super.init()
+    }
+
+    // MARK: Authorization
+
+    open func requestAuthorization(options: UNAuthorizationOptions = [],
+                                   completionHandler: @escaping @Sendable (Bool, (any Error)?) -> Void) {
+        Task { @MainActor in
+            do {
+                completionHandler(try await self.requestAuthorization(options: options), nil)
+            } catch {
+                completionHandler(false, error)
+            }
+        }
+    }
+
+    /// Asks the page for permission (`Notification.requestPermission()`):
+    /// `true` when granted. Without a Notification API it throws
+    /// `UNError(.notificationsNotAllowed)`.
+    open func requestAuthorization(options: UNAuthorizationOptions = []) async throws -> Bool {
+        let permission = await askPermission(action: "request")
+        if permission == "unsupported" { throw UNError(.notificationsNotAllowed) }
+        return permission == "granted"
+    }
+
+    open func getNotificationSettings(completionHandler: @escaping @Sendable (UNNotificationSettings) -> Void) {
+        Task { @MainActor in completionHandler(await self.notificationSettings()) }
+    }
+
+    open func notificationSettings() async -> UNNotificationSettings {
+        UNNotificationSettings(authorizationStatus: Self.status(of: await askPermission(action: "status")))
+    }
+
+    static func status(of permission: String) -> UNAuthorizationStatus {
+        switch permission {
+        case "granted": .authorized
+        case "default": .notDetermined
+        default: .denied
+        }
+    }
+
+    /// `status` reads `Notification.permission`; `request` asks the viewer.
+    @MainActor private func askPermission(action: String) async -> String {
+        let headless = action == "request" ? "granted" : lock.withLock { knownPermission }
+        let answer = try? await transport(.object(["action": .string(action)]), .object(["permission": .string(headless)]))
+        guard case .object(let fields)? = answer, case .string(let permission)? = fields["permission"] else { return "unsupported" }
+        lock.withLock { knownPermission = permission }
+        return permission
+    }
+
+    // MARK: Scheduling
+
+    /// Schedules the request, replacing a pending one with the same identifier.
+    /// Delivered when its trigger fires, at once without one, if the page is
+    /// still open then.
+    open func add(_ request: UNNotificationRequest, withCompletionHandler completionHandler: (@Sendable ((any Error)?) -> Void)? = nil) {
+        schedule(request, now: Date())
+        if let completionHandler { Task { @MainActor in completionHandler(nil) } }
+    }
+
+    open func add(_ request: UNNotificationRequest) async throws {
+        schedule(request, now: Date())
+    }
+
+    open func getPendingNotificationRequests(completionHandler: @escaping @Sendable ([UNNotificationRequest]) -> Void) {
+        let requests = pendingNotificationRequestsNow()
+        Task { @MainActor in completionHandler(requests) }
+    }
+
+    open func pendingNotificationRequests() async -> [UNNotificationRequest] {
+        pendingNotificationRequestsNow()
+    }
+
+    open func removePendingNotificationRequests(withIdentifiers identifiers: [String]) {
+        let removed: [Scheduled] = lock.withLock {
+            let removed = pending.filter { identifiers.contains($0.request.identifier) }
+            pending.removeAll { identifiers.contains($0.request.identifier) }
+            return removed
+        }
+        for entry in removed { entry.timer?.cancel() }
+    }
+
+    open func removeAllPendingNotificationRequests() {
+        let removed: [Scheduled] = lock.withLock {
+            defer { pending.removeAll() }
+            return pending
+        }
+        for entry in removed { entry.timer?.cancel() }
+    }
+
+    /// When each pending request fires next (nil: never), for tests.
+    func pendingFireDates() -> [String: Date?] {
+        lock.withLock { Dictionary(pending.map { ($0.request.identifier, $0.fireDate) }, uniquingKeysWith: { _, last in last }) }
+    }
+
+    private func pendingNotificationRequestsNow() -> [UNNotificationRequest] {
+        lock.withLock { pending.map(\.request) }
+    }
+
+    private func schedule(_ request: UNNotificationRequest, now: Date) {
+        let fireDate: Date? = request.trigger.map { $0.nextFireDate(after: now) } ?? now
+        let replaced: Scheduled? = lock.withLock {
+            let token = nextToken
+            nextToken += 1
+            let old = pending.first { $0.request.identifier == request.identifier }
+            pending.removeAll { $0.request.identifier == request.identifier }
+            let timer = fireDate.map { startTimer(identifier: request.identifier, token: token, delay: $0.timeIntervalSince(now)) }
+            pending.append(Scheduled(request: request, fireDate: fireDate, token: token, timer: timer))
+            return old
+        }
+        replaced?.timer?.cancel()
+    }
+
+    private func startTimer(identifier: String, token: Int, delay: TimeInterval) -> Task<Void, Never> {
+        Task { @MainActor [weak self] in
+            var remaining = max(0, delay)
+            repeat {
+                let step = min(remaining, Self.longestSleep)
+                do { try await Task.sleep(for: .milliseconds(Int64((step * 1000).rounded()))) } catch { return }
+                remaining -= step
+            } while remaining > 0
+            await self?.fire(identifier: identifier, token: token)
+        }
+    }
+
+    /// Delivers a pending request whose timer ran out (unless it was removed
+    /// or replaced meanwhile), and schedules its next delivery if it repeats.
+    @MainActor private func fire(identifier: String, token: Int) async {
+        let now = Date()
+        let notification: UNNotification? = lock.withLock {
+            guard let index = pending.firstIndex(where: { $0.request.identifier == identifier && $0.token == token }) else { return nil }
+            let entry = pending.remove(at: index)
+            let notification = UNNotification(date: now, request: entry.request)
+            delivered.removeAll { $0.request.identifier == identifier }
+            delivered.append(notification)
+            if let trigger = entry.request.trigger, trigger.repeats {
+                // After the date it was due, not just now: a timer may run a
+                // few milliseconds early, and the same match must not fire twice.
+                let after = max(now, entry.fireDate ?? now)
+                let next = trigger.nextFireDate(after: after)
+                let nextToken = self.nextToken
+                self.nextToken += 1
+                let timer = next.map { startTimer(identifier: identifier, token: nextToken, delay: $0.timeIntervalSince(now)) }
+                pending.insert(Scheduled(request: entry.request, fireDate: next, token: nextToken, timer: timer), at: index)
+            }
+            return notification
+        }
+        guard let notification else { return }
+        var options = Self.showEverything
+        if let delegate { options = await delegate.userNotificationCenter(self, willPresent: notification) }
+        await present(notification, options: options)
+    }
+
+    @MainActor private func present(_ notification: UNNotification, options: UNNotificationPresentationOptions) async {
+        let content = notification.request.content
+        var params: [String: _JSON] = ["action": .string("show"), "id": .string(notification.request.identifier)]
+        if !options.isDisjoint(with: [.banner, .alert, .list]) {
+            params["title"] = .string(content.title)
+            params["subtitle"] = .string(content.subtitle)
+            params["body"] = .string(content.body)
+            params["silent"] = .bool(content.sound == nil || !options.contains(.sound))
+        }
+        if options.contains(.badge), let badge = content.badge { params["badge"] = .number(badge.doubleValue) }
+        guard params["title"] != nil || params["badge"] != nil else { return }
+        let granted = lock.withLock { knownPermission } == "granted"
+        _ = try? await transport(.object(params), .object(["shown": .bool(granted)]))
+    }
+
+    // MARK: Delivered notifications and the badge
+
+    open func getDeliveredNotifications(completionHandler: @escaping @Sendable ([UNNotification]) -> Void) {
+        let notifications = lock.withLock { delivered }
+        Task { @MainActor in completionHandler(notifications) }
+    }
+
+    open func deliveredNotifications() async -> [UNNotification] {
+        lock.withLock { delivered }
+    }
+
+    /// Closes the browser notifications still on screen for these identifiers.
+    open func removeDeliveredNotifications(withIdentifiers identifiers: [String]) {
+        let removed: [String] = lock.withLock {
+            let ids = delivered.map(\.request.identifier).filter { identifiers.contains($0) }
+            delivered.removeAll { identifiers.contains($0.request.identifier) }
+            return ids
+        }
+        close(removed)
+    }
+
+    open func removeAllDeliveredNotifications() {
+        let removed: [String] = lock.withLock {
+            defer { delivered.removeAll() }
+            return delivered.map(\.request.identifier)
+        }
+        close(removed)
+    }
+
+    private func close(_ identifiers: [String]) {
+        guard !identifiers.isEmpty else { return }
+        let transport = self.transport
+        Task { @MainActor in
+            _ = try? await transport(.object(["action": .string("close"), "ids": .array(identifiers.map { .string($0) })]), .object([:]))
+        }
+    }
+
+    /// The app badge (`navigator.setAppBadge`; 0 clears it), where the browser has one.
+    open func setBadgeCount(_ newBadgeCount: Int, withCompletionHandler completionHandler: (@Sendable ((any Error)?) -> Void)? = nil) {
+        Task { @MainActor in
+            try? await self.setBadgeCount(newBadgeCount)
+            completionHandler?(nil)
+        }
+    }
+
+    open func setBadgeCount(_ newBadgeCount: Int) async throws {
+        _ = try? await transport(.object(["action": .string("badge"), "badge": .number(Double(newBadgeCount))]), .object([:]))
+    }
+}