@swiftbrowser/native 0.17.7 → 0.18.0

package/swift/Sources/SwiftBrowserNative/Host/NotificationBridge.swift

@@ -0,0 +1,304 @@
+#if canImport(SwiftUI) && canImport(UserNotifications)
+import Foundation
+import SwiftBrowserProtocol
+import UserNotifications
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app's notifications (packages/native/src/notifications.ts) on
+/// UserNotifications: the permission, local notifications (the runtime's
+/// `Notification`), the badge, and remote notifications (`registerForPush`),
+/// whose device token the app delegate hands to `NativeApp` (NativeAppDelegate.swift).
+/// What the viewer does with a notification, and what arrives while the app
+/// is open, goes to the app as `__sbNotification(json)`:
+///
+/// ```
+/// { "event": "opened" | "received", "remote": bool, "id": string, "title": string, "body": string, "data": {…}, "action"?: string }
+/// ```
+///
+/// `data` is the notification's `userInfo` (a push's payload; what
+/// `new Notification(title, { data })` gave). Against the shim (the round
+/// trip) the UserNotifications here is the shim's, which shows local
+/// notifications with the page's Notification API and subscribes to Web Push
+/// through the site's service worker (docs/ops-protocol.md, "Push
+/// notifications"), so one app runs in both.
+@MainActor
+final class NotificationBridge {
+    private let send: (String, [JSONValue]) -> Void
+    /// `pushRegister` calls waiting for a device token, by id.
+    private var registering: [Int] = []
+    /// Whether the app's `__sbNotification` is there to call (`notificationsReady`).
+    private(set) var ready = false
+
+    /// `send` calls a global of the app's.
+    init(send: @escaping (String, [JSONValue]) -> Void) {
+        self.send = send
+        NotificationRouter.shared.attach(self)
+    }
+
+    /// The app listens: what came before (a tap that launched the app) is delivered.
+    func listen() {
+        ready = true
+        NotificationRouter.shared.flush()
+    }
+
+    // MARK: Permission
+
+    /// Answers `__sbNotificationPermission(id, "granted" | "denied" | "default")`,
+    /// after asking the viewer when `request` is set and the question is open.
+    func permission(id: Int, request: Bool) {
+        Task { @MainActor in
+            let center = UNUserNotificationCenter.current()
+            if request {
+                _ = try? await center.requestAuthorization(options: [.alert, .badge, .sound])
+            }
+            let settings = await center.notificationSettings()
+            let answer: String = switch settings.authorizationStatus {
+            case .authorized, .provisional, .ephemeral: "granted"
+            case .denied: "denied"
+            default: "default"
+            }
+            send("__sbNotificationPermission", [.number(Double(id)), .string(answer)])
+        }
+    }
+
+    // MARK: Local notifications
+
+    /// Shows `{ id, title, subtitle?, body?, data?, badge?, silent? }` now; the message of what was wrong, or nil.
+    func show(_ json: String) -> String? {
+        let fields: JSONObject
+        do {
+            guard let parsed = try JSONValue.parse(json).object else { return "notification: expected an object" }
+            fields = parsed
+        } catch {
+            return "notification: \(error)"
+        }
+        guard let id = fields["id"]?.string, let title = fields["title"]?.string else { return "notification: expected an id and a title" }
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.subtitle = fields["subtitle"]?.string ?? ""
+        content.body = fields["body"]?.string ?? ""
+        if let badge = fields["badge"]?.int { content.badge = NSNumber(value: badge) }
+        if fields["silent"]?.bool != true { content.sound = .default }
+        if let data = fields["data"]?.object { content.userInfo = Self.userInfo(of: data) }
+        UNUserNotificationCenter.current().add(UNNotificationRequest(identifier: id, content: content, trigger: nil)) { _ in }
+        return nil
+    }
+
+    /// Closes the notifications with these identifiers (`[id, …]`).
+    func close(_ json: String) {
+        guard let ids = (try? JSONValue.parse(json))?.array?.compactMap(\.string), !ids.isEmpty else { return }
+        let center = UNUserNotificationCenter.current()
+        center.removePendingNotificationRequests(withIdentifiers: ids)
+        center.removeDeliveredNotifications(withIdentifiers: ids)
+    }
+
+    func setBadge(_ count: Int) {
+        UNUserNotificationCenter.current().setBadgeCount(max(0, count)) { _ in }
+    }
+
+    // MARK: Remote notifications
+
+    /// Registers with the system; the token or the failure answers
+    /// `__sbPushRegistered(id, { token } | { error })` through `NativeApp`'s
+    /// delegate entry points. `applicationServerKey` is what the page
+    /// subscribes with in the round trip (the shim's Web Push); the system
+    /// needs none.
+    func registerForPush(id: Int, applicationServerKey: String?) {
+        registering.append(id)
+        Self.systemRegistration(applicationServerKey)
+    }
+
+    /// Asks the system for a device token; tests substitute it.
+    static var systemRegistration: @MainActor (_ applicationServerKey: String?) -> Void = { applicationServerKey in
+        #if canImport(FoundationBridge)
+        if let applicationServerKey { _RemoteNotifications.applicationServerKey = applicationServerKey }
+        // The page has no App file with a delegate adaptor: the token needs one.
+        if UIApplication.shared.delegate == nil { UIApplication.shared.delegate = NativeAppDelegate() }
+        #endif
+        #if canImport(UIKit)
+        UIApplication.shared.registerForRemoteNotifications()
+        #elseif canImport(AppKit)
+        NSApplication.shared.registerForRemoteNotifications()
+        #endif
+    }
+
+    func registered(token: String) {
+        answerRegistrations(.object(["token": .string(token)]))
+    }
+
+    func registrationFailed(_ message: String) {
+        answerRegistrations(.object(["error": .string(message)]))
+    }
+
+    private func answerRegistrations(_ result: JSONValue) {
+        let ids = registering
+        registering = []
+        for id in ids { send("__sbPushRegistered", [.number(Double(id)), result]) }
+    }
+
+    /// A notification event for the app.
+    func deliver(_ event: JSONValue) {
+        send("__sbNotification", [.string(event.json)])
+    }
+
+    // MARK: Conversions
+
+    nonisolated static func userInfo(of fields: JSONObject) -> [AnyHashable: Any] {
+        var info: [AnyHashable: Any] = [:]
+        for (key, value) in fields { info[key] = foundationValue(of: value) }
+        return info
+    }
+
+    nonisolated static func foundationValue(of value: JSONValue) -> Any {
+        switch value {
+        case .null: NSNull()
+        case .bool(let bool): bool
+        case .number(let number): number == number.rounded() && abs(number) < 1e15 ? Int(number) : number
+        case .string(let string): string
+        case .array(let values): values.map(foundationValue(of:))
+        case .object(let fields): fields.mapValues(foundationValue(of:))
+        }
+    }
+
+    /// `userInfo` as JSON: strings, numbers, booleans, arrays and dictionaries with string keys; the rest is left out.
+    nonisolated static func jsonValue(of value: Any) -> JSONValue? {
+        switch value {
+        case let string as String: .string(string)
+        case let bool as Bool: .bool(bool)
+        case let int as Int: .number(Double(int))
+        case let double as Double: .number(double)
+        case let number as NSNumber: .number(number.doubleValue)
+        case is NSNull: .null
+        case let values as [Any]: .array(values.compactMap(jsonValue(of:)))
+        case let fields as [AnyHashable: Any]:
+            .object(fields.reduce(into: JSONObject()) { out, entry in
+                if let key = entry.key as? String, let json = jsonValue(of: entry.value) { out[key] = json }
+            })
+        default: nil
+        }
+    }
+
+    /// The event for a notification: `opened` with the action the viewer chose, or `received`.
+    nonisolated static func event(_ name: String, _ notification: UNNotification, action: String?) -> JSONValue {
+        let request = notification.request
+        return event(name, remote: request.trigger is UNPushNotificationTrigger, id: request.identifier,
+                     title: request.content.title, body: request.content.body, userInfo: request.content.userInfo, action: action)
+    }
+
+    nonisolated static func event(_ name: String, remote: Bool, id: String, title: String, body: String, userInfo: [AnyHashable: Any], action: String?) -> JSONValue {
+        var fields: JSONObject = [
+            "event": .string(name),
+            "remote": .bool(remote),
+            "id": .string(id),
+            "title": .string(title),
+            "body": .string(body),
+            "data": jsonValue(of: userInfo) ?? .object([:]),
+        ]
+        if let action { fields["action"] = .string(action) }
+        return .object(fields)
+    }
+}
+
+/// The notification center's delegate, shared by every `NativeApp`, which
+/// routes what the center reports to the apps' bridges: what the viewer
+/// opened (`didReceive`), what arrived while the app is open (`willPresent`,
+/// shown as it would be in the background), and the device token the app
+/// delegate was handed. What comes before an app listens (a tap that
+/// launched the app) waits for the first one.
+@MainActor
+final class NotificationRouter: NSObject, UNUserNotificationCenterDelegate {
+    static let shared = NotificationRouter()
+
+    private final class Weak {
+        weak var bridge: NotificationBridge?
+        init(_ bridge: NotificationBridge) { self.bridge = bridge }
+    }
+
+    private var bridges: [Weak] = []
+    private var pending: [JSONValue] = []
+    private var installed = false
+
+    /// Makes the router the center's delegate, once; before the app finishes
+    /// launching, for a tap that launches it.
+    func install() {
+        guard !installed else { return }
+        installed = true
+        UNUserNotificationCenter.current().delegate = self
+    }
+
+    /// `install` when the process is an app: a test runner has no
+    /// notification center (`UNUserNotificationCenter.current()` raises there).
+    func installIfApp() {
+        #if canImport(FoundationBridge)
+        install()
+        #else
+        if Bundle.main.bundleURL.pathExtension == "app" { install() }
+        #endif
+    }
+
+    func attach(_ bridge: NotificationBridge) {
+        bridges.removeAll { $0.bridge == nil }
+        bridges.append(Weak(bridge))
+    }
+
+    private var listening: [NotificationBridge] { bridges.compactMap(\.bridge).filter(\.ready) }
+
+    func flush() {
+        let targets = listening
+        guard !targets.isEmpty, !pending.isEmpty else { return }
+        let events = pending
+        pending = []
+        for event in events { for bridge in targets { bridge.deliver(event) } }
+    }
+
+    func route(_ event: JSONValue) {
+        let targets = listening
+        if targets.isEmpty {
+            pending.append(event)
+            return
+        }
+        for bridge in targets { bridge.deliver(event) }
+    }
+
+    func registered(token: Data) {
+        let hex = token.map { byte in
+            let digits = Array("0123456789abcdef")
+            return String([digits[Int(byte >> 4)], digits[Int(byte & 0x0f)]])
+        }.joined()
+        for bridge in bridges.compactMap(\.bridge) { bridge.registered(token: hex) }
+    }
+
+    func registrationFailed(_ message: String) {
+        for bridge in bridges.compactMap(\.bridge) { bridge.registrationFailed(message) }
+    }
+
+    /// A push the app delegate was handed (a silent one, or one with
+    /// `content-available`); one with an alert the center reports as it shows it.
+    func received(remote userInfo: [AnyHashable: Any]) {
+        let aps = userInfo["aps"] as? [AnyHashable: Any] ?? [:]
+        guard aps["alert"] == nil else { return }
+        route(NotificationBridge.event("received", remote: true, id: (userInfo["id"] as? String) ?? "", title: "", body: "", userInfo: userInfo, action: nil))
+    }
+
+    // MARK: UNUserNotificationCenterDelegate
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
+        let event = NotificationBridge.event("received", notification, action: nil)
+        await MainActor.run { route(event) }
+        return [.banner, .list, .sound, .badge]
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async {
+        let action = response.actionIdentifier == UNNotificationDefaultActionIdentifier ? "" : response.actionIdentifier
+        let event = NotificationBridge.event("opened", response.notification, action: action)
+        await MainActor.run { route(event) }
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/SecureStorage.swift

@@ -0,0 +1,60 @@
+#if canImport(SwiftUI)
+import Foundation
+#if canImport(FoundationBridge)
+import FoundationBridge
+#else
+import Security
+#endif
+
+/// The app's `secureStorage` (packages/native/src/secureStorage.ts): generic
+/// password items in the Keychain under the app's service, one per key,
+/// readable after the first unlock (a background fetch can read a token).
+/// Against the shim (the round trip) there is no Keychain: the values go to
+/// `UserDefaults` under a prefix, which is the page's `localStorage`.
+enum SecureStorage {
+    #if canImport(FoundationBridge)
+    private static let prefix = "swiftbrowser.secure."
+
+    static func get(_ key: String) -> String? {
+        UserDefaults.standard.string(forKey: prefix + key)
+    }
+
+    static func set(_ key: String, _ value: String) {
+        UserDefaults.standard.set(value, forKey: prefix + key)
+    }
+
+    static func remove(_ key: String) {
+        UserDefaults.standard.removeObject(forKey: prefix + key)
+    }
+    #else
+    private static var service: String { (Bundle.main.bundleIdentifier ?? "swiftbrowser") + ".secure" }
+
+    private static func query(_ key: String) -> [String: Any] {
+        [kSecClass as String: kSecClassGenericPassword, kSecAttrService as String: service, kSecAttrAccount as String: key]
+    }
+
+    static func get(_ key: String) -> String? {
+        var query = query(key)
+        query[kSecReturnData as String] = true
+        query[kSecMatchLimit as String] = kSecMatchLimitOne
+        var item: CFTypeRef?
+        guard SecItemCopyMatching(query as CFDictionary, &item) == errSecSuccess, let data = item as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    static func set(_ key: String, _ value: String) {
+        var attributes: [String: Any] = [kSecValueData as String: Data(value.utf8)]
+        #if os(iOS) || os(tvOS) || os(watchOS) || os(visionOS)
+        attributes[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
+        #endif
+        let status = SecItemUpdate(query(key) as CFDictionary, attributes as CFDictionary)
+        guard status == errSecItemNotFound else { return }
+        SecItemAdd(query(key).merging(attributes) { $1 } as CFDictionary, nil)
+    }
+
+    static func remove(_ key: String) {
+        SecItemDelete(query(key) as CFDictionary)
+    }
+    #endif
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/ShimAliases.swift

@@ -17,6 +17,7 @@ public typealias RunLoop = FoundationBridge.RunLoop
 public typealias UserDefaults = FoundationBridge.UserDefaults
 public typealias Bundle = FoundationBridge.Bundle
 public typealias URLSession = FoundationBridge.URLSession
+public typealias URLSessionWebSocketTask = FoundationBridge.URLSessionWebSocketTask
 public typealias URLSessionConfiguration = FoundationBridge.URLSessionConfiguration
 public typealias URLRequest = FoundationBridge.URLRequest
 public typealias URLResponse = FoundationBridge.URLResponse

package/swift/Sources/SwiftBrowserNative/Host/TextMeasureBridge.swift

@@ -0,0 +1,139 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+/// `measureText(text, fontJSON, width)` for @swiftbrowser/react's
+/// `measureText`: the size `text` takes in the font (a Font JSON object:
+/// `textStyle` or `size`, `weight`, `design`; the body font when empty)
+/// wrapped to `width` points (one line when null), from
+/// `NSAttributedString`'s bounding rect with the platform font, so an app
+/// paginating from text sizes gets what UIKit draws. Answers
+/// `{ width, height, lines }` (`lines` is the height in the font's line
+/// heights), or nil where there is no text system (the shim's round trip).
+enum TextMeasureBridge {
+    static func measure(text: String, font fontJSON: JSONValue, width: Double?) -> JSONValue? {
+        #if (canImport(UIKit) || canImport(AppKit)) && !canImport(FoundationBridge) // the shim's stand-ins have no text system
+        let font = platformFont(FontSpec(json: fontJSON))
+        let bounds = CGSize(width: width.map { CGFloat(max(1, $0)) } ?? .greatestFiniteMagnitude, height: .greatestFiniteMagnitude)
+        // An empty text is one line tall, as a `Text("")` is.
+        let measured = NSAttributedString(string: text.isEmpty ? " " : text, attributes: [.font: font])
+        let rect = measured.boundingRect(with: bounds, options: [.usesLineFragmentOrigin, .usesFontLeading], context: nil)
+        // The font's line height from the metrics UIFont and NSFont share (NSFont has no `lineHeight`).
+        let lineHeight = max(1, font.ascender - font.descender + font.leading)
+        let lines = max(1, Int((rect.height / lineHeight).rounded()))
+        return .object([
+            "width": .number(Double(text.isEmpty ? 0 : ceil(rect.width))),
+            "height": .number(Double(ceil(rect.height))),
+            "lines": .number(Double(lines)),
+        ])
+        #else
+        return nil
+        #endif
+    }
+
+    #if canImport(UIKit)
+    typealias PlatformFont = UIFont
+    #elseif canImport(AppKit)
+    typealias PlatformFont = NSFont
+    #endif
+
+    #if (canImport(UIKit) || canImport(AppKit)) && !canImport(FoundationBridge) // the shim's stand-ins have no text system
+    /// The platform font a Font JSON object names: a text style's preferred font (Dynamic Type) or a point size, with its weight and design.
+    static func platformFont(_ spec: FontSpec?) -> PlatformFont {
+        let weight = spec?.weight.map(platformWeight) ?? .regular
+        var font: PlatformFont
+        if let size = spec?.size {
+            font = PlatformFont.systemFont(ofSize: CGFloat(size), weight: weight)
+        } else {
+            #if canImport(UIKit)
+            let base = UIFont.preferredFont(forTextStyle: textStyle(spec?.textStyle ?? "body"))
+            font = spec?.weight == nil ? base : UIFont.systemFont(ofSize: base.pointSize, weight: weight)
+            #else
+            let base = NSFont.preferredFont(forTextStyle: textStyle(spec?.textStyle ?? "body"))
+            font = spec?.weight == nil ? base : NSFont.systemFont(ofSize: base.pointSize, weight: weight)
+            #endif
+        }
+        if let design = spec?.design.flatMap(platformDesign), let descriptor = font.fontDescriptor.withDesign(design) {
+            #if canImport(UIKit)
+            font = UIFont(descriptor: descriptor, size: font.pointSize)
+            #else
+            font = NSFont(descriptor: descriptor, size: font.pointSize) ?? font
+            #endif
+        }
+        return font
+    }
+
+    private static func platformWeight(_ name: String) -> PlatformFont.Weight {
+        switch name {
+        case "ultraLight": return .ultraLight
+        case "thin": return .thin
+        case "light": return .light
+        case "medium": return .medium
+        case "semibold": return .semibold
+        case "bold": return .bold
+        case "heavy": return .heavy
+        case "black": return .black
+        default: return .regular
+        }
+    }
+
+    #if canImport(UIKit)
+    private static func platformDesign(_ name: String) -> UIFontDescriptor.SystemDesign? {
+        switch name {
+        case "serif": return .serif
+        case "rounded": return .rounded
+        case "monospaced": return .monospaced
+        default: return nil
+        }
+    }
+
+    private static func textStyle(_ name: String) -> UIFont.TextStyle {
+        switch name {
+        case "largeTitle": return .largeTitle
+        case "title": return .title1
+        case "title2": return .title2
+        case "title3": return .title3
+        case "headline": return .headline
+        case "subheadline": return .subheadline
+        case "callout": return .callout
+        case "footnote": return .footnote
+        case "caption": return .caption1
+        case "caption2": return .caption2
+        default: return .body
+        }
+    }
+    #else
+    private static func platformDesign(_ name: String) -> NSFontDescriptor.SystemDesign? {
+        switch name {
+        case "serif": return .serif
+        case "rounded": return .rounded
+        case "monospaced": return .monospaced
+        default: return nil
+        }
+    }
+
+    private static func textStyle(_ name: String) -> NSFont.TextStyle {
+        switch name {
+        case "largeTitle": return .largeTitle
+        case "title": return .title1
+        case "title2": return .title2
+        case "title3": return .title3
+        case "headline": return .headline
+        case "subheadline": return .subheadline
+        case "callout": return .callout
+        case "footnote": return .footnote
+        case "caption": return .caption1
+        case "caption2": return .caption2
+        default: return .body
+        }
+    }
+    #endif
+    #endif
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/UndoBridge.swift

@@ -0,0 +1,170 @@
+#if canImport(SwiftUI) && !canImport(FoundationBridge)
+import Foundation
+import SwiftBrowserProtocol
+
+/// The app's undo manager (`useUndoManager` in @swiftbrowser/react,
+/// packages/native/src/undo.ts) on the window's `UndoManager`, so the
+/// system's undo reaches it: the shake and the three-finger swipe on iOS,
+/// ⌘Z and ⇧⌘Z from a keyboard, the Edit menu on macOS. The JavaScript stack
+/// is the truth (its closures are JavaScript, and `canUndo` must change in
+/// the pass that registered them); the window's manager mirrors it. Each
+/// `undoState(json)` (`canUndo`, `canRedo`, `undoActionName`,
+/// `redoActionName`) rebuilds the mirror: one proxy action on the undo
+/// stack when the app can undo and one on the redo stack when it can redo,
+/// named as the app names them, each sending `__sbUndoCommand("undo" |
+/// "redo")` when the system runs it. The redo stack is reached the only
+/// way `UndoManager` allows, from inside an undo: on the turn after the
+/// undo proxy's (whose event group the run loop has closed by then), a
+/// no-op is registered and undone at once, and the proxy it registers
+/// while undoing lands on the redo stack. A proxy the system runs calls
+/// into the app, whose new state arrives while the manager is still
+/// undoing, so the mirror is rebuilt on the next turn of the run loop.
+///
+/// Against the shim (the round trip) the page's keyboard is the host and
+/// this file is empty.
+@MainActor
+final class UndoBridge {
+    struct State: Equatable {
+        var canUndo = false
+        var canRedo = false
+        var undoActionName = ""
+        var redoActionName = ""
+    }
+
+    private let send: (String) -> Void
+    private(set) var state = State()
+    /// What the mirror does, for the tests (nil: nothing is traced).
+    nonisolated(unsafe) static var trace: (@MainActor (String) -> Void)?
+    /// Whether a proxy is running the app's undo or redo: the state it sends back is mirrored afterwards.
+    private var applying = false
+    /// The window's manager, from the root view's environment.
+    weak var manager: UndoManager? {
+        didSet {
+            if manager !== oldValue {
+                if let oldValue {
+                    oldValue.removeAllActions(withTarget: self)
+                    // A proxy registered this turn sits in an event group still
+                    // open, out of `removeAllActions`'s reach until the turn ends.
+                    DispatchQueue.main.async { [weak self] in
+                        MainActor.assumeIsolated { if let self { oldValue.removeAllActions(withTarget: self) } }
+                    }
+                }
+                mirror()
+            }
+        }
+    }
+
+    /// `send` hands the system's `undo` or `redo` to the app.
+    init(send: @escaping (String) -> Void) {
+        self.send = send
+    }
+
+    /// Applies one state; the message of what was wrong with it, or nil.
+    func update(_ json: String) -> String? {
+        let parsed: JSONValue
+        do {
+            parsed = try JSONValue.parse(json)
+        } catch {
+            return "undoState: \(error)"
+        }
+        guard let fields = parsed.object else { return "undoState: expected an object" }
+        state = State(
+            canUndo: fields.bool("canUndo") ?? false,
+            canRedo: fields.bool("canRedo") ?? false,
+            undoActionName: fields.string("undoActionName") ?? "",
+            redoActionName: fields.string("redoActionName") ?? ""
+        )
+        if !applying { mirror() }
+        return nil
+    }
+
+    /// Rebuilds the window's manager from `state`; while another group is open on it, on the next turn of the run loop.
+    private func mirror() {
+        guard let manager else { return }
+        guard manager.groupingLevel == 0 else {
+            afterTurn { $0.mirror() }
+            return
+        }
+        Self.trace?("mirror level=\(manager.groupingLevel) before: \(describe(manager)) state: \(state)")
+        manager.removeAllActions(withTarget: self)
+        Self.trace?("mirror after removeAllActions: \(describe(manager))")
+        // The undo proxy first: a registration made while not undoing clears
+        // the redo stack, so the redo proxy must be the last thing planted,
+        // and on the next turn: this turn's event group stays open around
+        // the undo proxy until the run loop ends it, and the no-op's
+        // `undo()` would close and undo it whole.
+        if state.canUndo {
+            manager.beginUndoGrouping()
+            registerProxy("undo", named: state.undoActionName)
+            manager.endUndoGrouping()
+        }
+        if state.canRedo { later { $0.plantRedo(attempts: 3) } }
+    }
+
+    /// The redo proxy, from inside the undo of a no-op: on a turn with no
+    /// group open (a later one while this one's event group is still open:
+    /// a block run in the same drain of the main queue as the registration
+    /// that opened it comes before the run loop's end of the turn).
+    private func plantRedo(attempts: Int) {
+        guard let manager else { return }
+        Self.trace?("plantRedo attempts=\(attempts) level=\(manager.groupingLevel) \(describe(manager)) state.canRedo=\(state.canRedo)")
+        guard state.canRedo, !manager.canRedo else { return }
+        guard manager.groupingLevel == 0 else {
+            if attempts > 0 { afterTurn { $0.plantRedo(attempts: attempts - 1) } }
+            return
+        }
+        manager.beginUndoGrouping()
+        manager.registerUndo(withTarget: self) { target in
+            MainActor.assumeIsolated { target.registerProxy("redo", named: target.state.redoActionName) }
+        }
+        manager.endUndoGrouping()
+        Self.trace?("plantRedo before undo(): \(describe(manager))")
+        manager.undo()
+        Self.trace?("plantRedo after undo(): \(describe(manager))")
+    }
+
+    private func describe(_ manager: UndoManager) -> String {
+        "undo=\(manager.canUndo)/\(manager.undoActionName) redo=\(manager.canRedo)/\(manager.redoActionName) undoing=\(manager.isUndoing) redoing=\(manager.isRedoing) level=\(manager.groupingLevel)"
+    }
+
+    /// Registers the proxy that sends `command`, on whichever stack the manager is filling.
+    private func registerProxy(_ command: String, named name: String) {
+        guard let manager else { return }
+        manager.registerUndo(withTarget: self) { target in
+            MainActor.assumeIsolated { target.perform(command) }
+        }
+        manager.setActionName(name)
+    }
+
+    /// The system ran a proxy: the app undoes or redoes, and the mirror follows once the manager is done.
+    private func perform(_ command: String) {
+        guard let manager else { return } // taken away: a proxy left in a group that was open then
+        Self.trace?("perform \(command): \(describe(manager))")
+        applying = true
+        send(command)
+        applying = false
+        // What the app can now do the other way, so the manager is right at once; the rebuild confirms it.
+        if command == "undo", state.canRedo { registerProxy("redo", named: state.redoActionName) }
+        if command == "redo", state.canUndo { registerProxy("undo", named: state.undoActionName) }
+        mirrorLater()
+    }
+
+    private func mirrorLater() {
+        later { $0.mirror() }
+    }
+
+    /// `body` on the next drain of the main queue, with this bridge.
+    private func later(_ body: @escaping @MainActor (UndoBridge) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            MainActor.assumeIsolated { if let self { body(self) } }
+        }
+    }
+
+    /// `body` a moment later, on a turn of the run loop after this one has ended (and closed its event group).
+    private func afterTurn(_ body: @escaping @MainActor (UndoBridge) -> Void) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(1)) { [weak self] in
+            MainActor.assumeIsolated { if let self { body(self) } }
+        }
+    }
+}
+#endif