@swiftbrowser/native 0.17.7 → 0.17.8

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/WebSocketBridge.swift

@@ -0,0 +1,118 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app's `WebSocket`s (packages/native/src/webSocket.ts) on
+/// `URLSessionWebSocketTask`: `wsOpen` starts one, which is open once its
+/// first ping is answered (the handshake is done by then), `wsSend` sends
+/// text or bytes, `wsClose` closes it. What a socket receives, and how it
+/// ends, goes to the app as `__sbWebSocketEvent(id, json)`: `open`,
+/// `message` (`text` or base64 `binary`), `error` and `close` (`code`,
+/// `reason`, `wasClean`). Against the shim (the round trip) the task is the
+/// shim's, over the page's WebSocket.
+@MainActor
+final class WebSocketBridge {
+    private let session: URLSession
+    private let send: (Int, JSONValue) -> Void
+    private var tasks: [Int: URLSessionWebSocketTask] = [:]
+
+    /// `send` hands an event for socket `id` to the app.
+    init(session: URLSession, send: @escaping (Int, JSONValue) -> Void) {
+        self.session = session
+        self.send = send
+    }
+
+    func open(id: Int, url string: String, protocols: [String]) {
+        guard let url = URL(string: string) else {
+            emit(id, ["type": .string("error"), "message": .string("invalid URL")])
+            emit(id, ["type": .string("close"), "code": .number(1006), "reason": .string(""), "wasClean": .bool(false)])
+            return
+        }
+        let task = protocols.isEmpty ? session.webSocketTask(with: url) : session.webSocketTask(with: url, protocols: protocols)
+        tasks[id] = task
+        task.resume()
+        task.sendPing { [weak self] error in
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                if let error {
+                    self.fail(id: id, task: task, error: error)
+                    return
+                }
+                self.emit(id, ["type": .string("open"), "protocol": .string("")])
+                self.receive(id: id, task: task)
+            }
+        }
+    }
+
+    /// `{ text }` or `{ binary }` (base64).
+    func send(id: Int, json: String) {
+        guard let task = tasks[id], let fields = (try? JSONValue.parse(json))?.object else { return }
+        let message: URLSessionWebSocketTask.Message
+        if let text = fields["text"]?.string {
+            message = .string(text)
+        } else if let encoded = fields["binary"]?.string, let data = Data(base64Encoded: encoded) {
+            message = .data(data)
+        } else {
+            return
+        }
+        task.send(message) { [weak self] error in
+            guard let error else { return }
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                self.fail(id: id, task: task, error: error)
+            }
+        }
+    }
+
+    func close(id: Int, code: Int, reason: String) {
+        guard let task = tasks.removeValue(forKey: id) else { return }
+        task.cancel(with: URLSessionWebSocketTask.CloseCode(rawValue: code) ?? .normalClosure, reason: reason.isEmpty ? nil : Data(reason.utf8))
+        emit(id, ["type": .string("close"), "code": .number(Double(code)), "reason": .string(reason), "wasClean": .bool(true)])
+    }
+
+    /// Ends every socket; the app that owned the bridge is going away.
+    func invalidate() {
+        for task in tasks.values { task.cancel(with: .goingAway, reason: nil) }
+        tasks.removeAll()
+    }
+
+    private func receive(id: Int, task: URLSessionWebSocketTask) {
+        task.receive { [weak self] result in
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                switch result {
+                case .success(let message):
+                    switch message {
+                    case .string(let text): self.emit(id, ["type": .string("message"), "text": .string(text)])
+                    case .data(let data): self.emit(id, ["type": .string("message"), "binary": .string(data.base64EncodedString())])
+                    @unknown default: break
+                    }
+                    self.receive(id: id, task: task)
+                case .failure(let error):
+                    self.fail(id: id, task: task, error: error)
+                }
+            }
+        }
+    }
+
+    /// The socket ended: a close the server sent (its code and reason), else an error and an unclean close.
+    private func fail(id: Int, task: URLSessionWebSocketTask, error: any Error) {
+        tasks[id] = nil
+        let code = task.closeCode
+        if code != .invalid {
+            let reason = task.closeReason.map { String(decoding: $0, as: UTF8.self) } ?? ""
+            emit(id, ["type": .string("close"), "code": .number(Double(code.rawValue)), "reason": .string(reason), "wasClean": .bool(true)])
+        } else {
+            emit(id, ["type": .string("error"), "message": .string(error.localizedDescription)])
+            emit(id, ["type": .string("close"), "code": .number(1006), "reason": .string(""), "wasClean": .bool(false)])
+        }
+    }
+
+    private func emit(_ id: Int, _ fields: JSONObject) {
+        send(id, .object(fields))
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Runtime/NativeApp.swift

@@ -61,9 +61,35 @@ public final class NativeApp {
         #if canImport(JavaScriptCore)
         (host as? JavaScriptCoreHost)?.onError = { [weak self] error in self?.error = error.description }
         #endif
+        #if canImport(UserNotifications)
+        NotificationRouter.shared.installIfApp()
+        #endif
         bridge = HostBridge(host: host, tree: tree)
     }
 
+    #if canImport(UserNotifications)
+    // MARK: Remote notifications
+    //
+    // What the app delegate is handed (NativeAppDelegate.swift, or the app's
+    // own delegate calling these), for `registerForPush` and `onNotification`
+    // in `@swiftbrowser/native` (NotificationBridge.swift).
+
+    /// The device token: `registerForPush` resolves with it, as hex.
+    public static func didRegisterForRemoteNotifications(deviceToken: Data) {
+        NotificationRouter.shared.registered(token: deviceToken)
+    }
+
+    /// No token: `registerForPush` rejects with the error.
+    public static func didFailToRegisterForRemoteNotifications(error: any Error) {
+        NotificationRouter.shared.registrationFailed("\(error)")
+    }
+
+    /// A push delivered to the app delegate (a silent one): a `received` event.
+    public static func didReceiveRemoteNotification(userInfo: [AnyHashable: Any]) {
+        NotificationRouter.shared.received(remote: userInfo)
+    }
+    #endif
+
     /// Evaluates the app's bundle (what `@swiftbrowser/native` built: it calls
     /// `run(<App/>)` at the end, which renders the first pass into the tree
     /// before this returns). The environment, if known, is sent right after.

package/swift/Sources/SwiftBrowserNative/Runtime/NativeAppDelegate.swift

@@ -0,0 +1,36 @@
+#if canImport(SwiftUI) && canImport(UIKit) && canImport(UserNotifications)
+import Foundation
+import UIKit
+import UserNotifications
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app delegate a native app adopts for remote notifications, through
+/// `@UIApplicationDelegateAdaptor(NativeAppDelegate.self)` in its App file
+/// (the project `native init` writes does): it hands the device token, a
+/// failure to get one and the pushes delivered to the app to `NativeApp`,
+/// for `registerForPush` and `onNotification` in `@swiftbrowser/native`
+/// (NotificationBridge.swift). An app with a delegate of its own calls the
+/// same `NativeApp` entry points from it.
+open class NativeAppDelegate: UIResponder, UIApplicationDelegate {
+    open func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Before launching finishes, so a tap that launched the app is reported.
+        NotificationRouter.shared.install()
+        return true
+    }
+
+    open func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+        NativeApp.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    }
+
+    open func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {
+        NativeApp.didFailToRegisterForRemoteNotifications(error: error)
+    }
+
+    open func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult {
+        NativeApp.didReceiveRemoteNotification(userInfo: userInfo)
+        return .newData
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Controls.swift

@@ -71,9 +71,20 @@ struct ToggleElement: View {
     }
 }
 
-/// `textfield`: a controlled field. Each keystroke sends `text`; the app's
-/// state is the truth the getter reads back, with no frame in between
-/// because the dispatch is synchronous.
+/// The `text` event for a write to a field's binding, or nil when the
+/// field's text already is `value`. SwiftUI writes a text binding on a focus
+/// and a commit with the text it has, not only on a keystroke; the page's
+/// renderer sends `text` only for input, and an app that takes every `text`
+/// as an edit (Amindia's Discard button, appearing on a tap into a field)
+/// must hear only changes natively too.
+func textChange(of node: ElementNode, to value: String) -> RendererEvent? {
+    (node.props.string("text") ?? "") == value ? nil : .text(node.id, value)
+}
+
+/// `textfield`: a controlled field. Each keystroke sends `text` (a write of
+/// the text the field has sends nothing, `textChange`); the app's state is
+/// the truth the getter reads back, with no frame in between because the
+/// dispatch is synchronous.
 struct TextFieldElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
@@ -83,7 +94,7 @@ struct TextFieldElement: View {
         let props = TextFieldProps(props: node.props)
         let text = Binding(
             get: { TextFieldProps(props: node.props).text },
-            set: { app?.dispatch(.text(node.id, $0)) }
+            set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
         )
         let field: AnyView = {
             if props.secure { return AnyView(SecureField(props.placeholder, text: text)) }
@@ -133,7 +144,7 @@ struct TextEditorElement: View {
     var body: some View {
         TextEditor(text: Binding(
             get: { node.props.string("text") ?? "" },
-            set: { app?.dispatch(.text(node.id, $0)) }
+            set: { if let event = textChange(of: node, to: $0) { app?.dispatch(event) } }
         ))
     }
 }

package/wasm/SwiftBrowserNative.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/wasm/SwiftBrowserNative.wasm
-size: 49658341 bytes
-sha256: 9aa09e4a1125c88786c07b9293dd9eec6264583717cd1f8227808596da2d911a
+size: 49791914 bytes
+sha256: 32b3af1ab0d488c6d0d26f3f6e58f7c8886299aadb7f70dd25d2bf5a7e42c3f9