@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/FoundationBridge/Selector.swift

@@ -0,0 +1,226 @@
+// `#selector` without the Objective-C runtime. On Apple platforms a selector
+// names a method the runtime looks up when a message is sent. Here the
+// staging rewrites `#selector(handle(_:))` into
+// `Selector(Self.handle(_:), name: "handle(_:)")`: the method itself,
+// unbound, which the selector calls on whatever target the API holds (it
+// dispatches dynamically, so overrides are called). `@objc` is dropped from
+// the declarations (packages/cli/src/stage.ts, `rewriteObjC`).
+//
+// The APIs that take a target and a selector take this `Selector`:
+// `NotificationCenter.addObserver(_:selector:name:object:)`
+// (NotificationCenter.swift), `Timer`'s target/selector initializers (here),
+// and UIKit's `CADisplayLink`,
+// `UIControl.addTarget(_:action:for:)` and gesture recognizers. Selectors
+// made from strings (`Selector("tick")`, `NSSelectorFromString`) have a name
+// and nothing to call.
+
+import Foundation
+import SwiftUI
+
+public struct Selector: Hashable, CustomStringConvertible, ExpressibleByStringLiteral, @unchecked Sendable {
+    /// The method's name as the source spelled it; selectors compare by it.
+    public let name: String
+    let invoke: ((AnyObject, Any?) -> Void)?
+
+    public init(_ name: String) {
+        self.name = name
+        invoke = nil
+    }
+
+    public init(stringLiteral value: String) { self.init(value) }
+
+    /// A method without arguments.
+    public init<T: AnyObject, R>(_ method: @escaping (T) -> () -> R, name: String) {
+        self.name = name
+        invoke = { target, _ in
+            guard let target = target as? T else { return }
+            _ = method(target)()
+        }
+    }
+
+    /// A method with one argument: the sender, the notification, the timer.
+    public init<T: AnyObject, A, R>(_ method: @escaping (T) -> (A) -> R, name: String) {
+        self.name = name
+        invoke = { target, argument in
+            guard let target = target as? T, let argument = Self.cast(argument, to: A.self) else { return }
+            _ = method(target)(argument)
+        }
+    }
+
+    /// A method with two arguments (`(_:forEvent:)`); the second is nil when it can be.
+    public init<T: AnyObject, A, B, R>(_ method: @escaping (T) -> (A, B) -> R, name: String) {
+        self.name = name
+        invoke = { target, argument in
+            guard let target = target as? T, let first = Self.cast(argument, to: A.self),
+                  let second = Self.cast(nil, to: B.self) else { return }
+            _ = method(target)(first, second)
+        }
+    }
+
+    /// A main-actor method, bound to the target by a closure
+    /// (`{ (target: Proxy) in target.tick }`): Swift 6 does not let a
+    /// main-actor method of a class that is not `Sendable` be named unapplied.
+    /// The page has one thread, so the target is called on the main actor.
+    public init<T: AnyObject, R>(name: String, isolated method: @escaping @MainActor (T) -> @MainActor () -> R) {
+        self.name = name
+        nonisolated(unsafe) let method = method
+        invoke = { target, _ in
+            guard let target = target as? T else { return }
+            nonisolated(unsafe) let held = target
+            MainActor.assumeIsolated { _ = method(held)() }
+        }
+    }
+
+    public init<T: AnyObject, A, R>(name: String, isolated method: @escaping @MainActor (T) -> @MainActor (A) -> R) {
+        self.name = name
+        nonisolated(unsafe) let method = method
+        invoke = { target, argument in
+            guard let target = target as? T, let argument = Self.cast(argument, to: A.self) else { return }
+            nonisolated(unsafe) let held = target
+            nonisolated(unsafe) let value = argument
+            MainActor.assumeIsolated { _ = method(held)(value) }
+        }
+    }
+
+    /// A method of another object than the target (`#selector(model.refresh)`): it is called as it is.
+    public init<R>(bound method: @escaping () -> R, name: String) {
+        self.name = name
+        invoke = { _, _ in _ = method() }
+    }
+
+    public init<A, R>(bound method: @escaping (A) -> R, name: String) {
+        self.name = name
+        invoke = { _, argument in
+            guard let argument = Self.cast(argument, to: A.self) else { return }
+            _ = method(argument)
+        }
+    }
+
+    /// `argument` as an `A`; nil is an `A` when `A` is optional.
+    static func cast<A>(_ argument: Any?, to type: A.Type) -> A? {
+        if let argument, let value = argument as? A { return value }
+        return Optional<Any>.none as? A
+    }
+
+    /// Whether the selector was made from a method (`#selector`), not a string.
+    public var _hasMethod: Bool { invoke != nil }
+
+    /// Calls the method on `target`; a selector made from a string calls nothing.
+    public func _perform(on target: AnyObject, with argument: Any? = nil) {
+        invoke?(target, argument)
+    }
+
+    public var description: String { name }
+    public static func == (lhs: Selector, rhs: Selector) -> Bool { lhs.name == rhs.name }
+    public func hash(into hasher: inout Hasher) { hasher.combine(name) }
+}
+
+extension Selector {
+    nonisolated(unsafe) private static var pointers: [String: UnsafeMutableRawPointer] = [:]
+    private static let pointersLock = NSLock()
+
+    /// One address per selector name, as the runtime's uniqued selectors
+    /// have: what `unsafeBitCast(selector, to: UnsafeRawPointer.self)` gives on
+    /// Apple platforms, usually as an associated object's key
+    /// (`objc_setAssociatedObject`, CoreFoundation.swift). The staging rewrites
+    /// that bit cast, which would trap on this struct, into this property
+    /// (packages/cli/src/stage.ts, `selectorPointers`).
+    public var _uniquePointer: UnsafeRawPointer {
+        Self.pointersLock.lock(); defer { Self.pointersLock.unlock() }
+        if let pointer = Self.pointers[name] { return UnsafeRawPointer(pointer) }
+        let pointer = UnsafeMutableRawPointer.allocate(byteCount: 1, alignment: 1)
+        Self.pointers[name] = pointer
+        return UnsafeRawPointer(pointer)
+    }
+}
+
+public func NSSelectorFromString(_ name: String) -> Selector { Selector(name) }
+public func NSStringFromSelector(_ selector: Selector) -> String { selector.name }
+
+extension NSObject {
+    /// Whether the Objective-C runtime finds a method for the selector: there
+    /// is no runtime to ask, so never. Code that checks before calling a
+    /// method by name (`method(for:)`, `perform(_:)`) takes its fallback.
+    public func responds(to aSelector: Selector?) -> Bool { false }
+}
+
+// MARK: - Timers
+
+extension Timer {
+    /// A timer that calls `selector` on `target` (which it keeps) each time it fires.
+    @discardableResult
+    public static func scheduledTimer(timeInterval interval: TimeInterval, target: Any, selector aSelector: Selector, userInfo: Any?, repeats: Bool) -> Timer {
+        let target = target as AnyObject
+        nonisolated(unsafe) let held = target
+        let timer = Timer(interval: interval, repeats: repeats) { timer in aSelector._perform(on: held, with: timer) }
+        timer.userInfo = userInfo
+        return timer
+    }
+
+    /// As `scheduledTimer`; the timer runs at once (adding it to a run loop changes nothing).
+    public convenience init(timeInterval interval: TimeInterval, target: Any, selector aSelector: Selector, userInfo: Any?, repeats: Bool) {
+        let target = target as AnyObject
+        nonisolated(unsafe) let held = target
+        self.init(interval: interval, repeats: repeats) { timer in aSelector._perform(on: held, with: timer) }
+        self.userInfo = userInfo
+    }
+}
+
+// MARK: - Numbers read off any object
+
+/// What `x as? AnyObject` becomes in a file that reads a number off the
+/// result (`(props[key] as? AnyObject)?.doubleValue`; the CLI's staging,
+/// `numberCasts`). Objective-C finds `doubleValue` on any object at run time
+/// and answers nil where there is none; here the members are on the values a
+/// dictionary of `Any` holds: Swift's numbers, `Bool`, `String` and
+/// `NSNumber`. A type's own member of the same name (`NSNumber.doubleValue`)
+/// still wins on that type.
+public protocol _AnyObjectValue {}
+
+extension _AnyObjectValue {
+    var _number: Double? {
+        switch self as Any {
+        case let value as Double: value
+        case let value as Float: Double(value)
+        case let value as Int: Double(value)
+        case let value as Int8: Double(value)
+        case let value as Int16: Double(value)
+        case let value as Int32: Double(value)
+        case let value as Int64: Double(value)
+        case let value as UInt: Double(value)
+        case let value as UInt8: Double(value)
+        case let value as UInt16: Double(value)
+        case let value as UInt32: Double(value)
+        case let value as UInt64: Double(value)
+        case let value as Bool: value ? 1 : 0
+        case let value as NSNumber: value.doubleValue
+        case let value as String: Double(value)
+        default: nil
+        }
+    }
+
+    public var doubleValue: Double? { _number }
+    public var floatValue: Float? { _number.map { Float($0) } }
+    public var intValue: Int? { _number.map { Int($0) } }
+    public var integerValue: Int? { intValue }
+    public var int64Value: Int64? { _number.map { Int64($0) } }
+    public var uintValue: UInt? { _number.map { UInt(max(0, $0)) } }
+    public var uint64Value: UInt64? { _number.map { UInt64(max(0, $0)) } }
+    public var boolValue: Bool? { _number.map { $0 != 0 } }
+}
+
+extension Double: _AnyObjectValue {}
+extension Float: _AnyObjectValue {}
+extension Int: _AnyObjectValue {}
+extension Int8: _AnyObjectValue {}
+extension Int16: _AnyObjectValue {}
+extension Int32: _AnyObjectValue {}
+extension Int64: _AnyObjectValue {}
+extension UInt: _AnyObjectValue {}
+extension UInt8: _AnyObjectValue {}
+extension UInt16: _AnyObjectValue {}
+extension UInt32: _AnyObjectValue {}
+extension UInt64: _AnyObjectValue {}
+extension Bool: _AnyObjectValue {}
+extension String: _AnyObjectValue {}
+extension NSNumber: _AnyObjectValue {}

package/Sources/FoundationBridge/StringComparators.swift

@@ -0,0 +1,17 @@
+// String comparators that Apple's Foundation has and the SDK's does not.
+
+import Foundation
+
+// MARK: - Localized string comparators
+
+extension String.StandardComparator {
+    /// Finder-like ordering on Apple platforms (case-insensitive, numbers by
+    /// value, in the user's locale). The SDK's Foundation has only `.lexical`
+    /// off Apple platforms and builds no other comparator, so this orders as
+    /// `.lexical` does.
+    public static var localizedStandard: String.StandardComparator { .lexical }
+
+    /// The user's locale's ordering on Apple platforms; `.lexical` here (see
+    /// `localizedStandard`).
+    public static var localized: String.StandardComparator { .lexical }
+}

package/Sources/FoundationBridge/Table.swift

@@ -0,0 +1,211 @@
+// The parts of SwiftUI's `Table` that need Foundation's `KeyPathComparator`
+// (the shim's SwiftUI has no Foundation): sortable columns, which carry the
+// comparator their title sorts by, and the tables bound to a `sortOrder`.
+// Tapping a sortable column's title puts its comparator first in the sort
+// order, or reverses it when it is first already; the app sorts its rows by
+// the binding (the table itself is in Sources/SwiftUI/API/Table.swift).
+
+import Foundation
+import SwiftUI
+
+extension TableColumn where Sort == KeyPathComparator<RowValue>, Label == Text {
+    public init(_ titleKey: LocalizedStringKey, value: KeyPath<RowValue, String> & Sendable) where Content == Text {
+        self.init(_column: _TableColumn(title: Text(titleKey), sortComparator: KeyPathComparator(value)) {
+            AnyView(Text($0[keyPath: value]))
+        })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, value: KeyPath<RowValue, String> & Sendable) where Content == Text {
+        self.init(_column: _TableColumn(title: Text(String(title)), sortComparator: KeyPathComparator(value)) {
+            AnyView(Text($0[keyPath: value]))
+        })
+    }
+
+    public init<V: Comparable>(_ titleKey: LocalizedStringKey, value: KeyPath<RowValue, V> & Sendable,
+                               @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: Text(titleKey), sortComparator: KeyPathComparator(value)) {
+            AnyView(content($0))
+        })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol, V: Comparable>(_ title: S, value: KeyPath<RowValue, V> & Sendable,
+                                                  @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: Text(String(title)), sortComparator: KeyPathComparator(value)) {
+            AnyView(content($0))
+        })
+    }
+
+    public init<V: Comparable>(_ text: Text, value: KeyPath<RowValue, V> & Sendable, @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: text, sortComparator: KeyPathComparator(value)) { AnyView(content($0)) })
+    }
+}
+
+/// The sort a `sortOrder` binding makes of the column titles (see the top of the file).
+private func _tableSort<Value, Sort: SortComparator>(_ sortOrder: Binding<[Sort]>, _ columns: [_TableColumn<Value>]) -> _TableSort
+where Sort.Compared == Value {
+    _TableSort(order: { index in
+        guard let column = columns[index].sortComparator as? KeyPathComparator<Value>,
+              let first = sortOrder.wrappedValue.first as? KeyPathComparator<Value>,
+              first.keyPath == column.keyPath else { return nil }
+        return first.order == .forward
+    }, tap: { index in
+        guard var column = columns[index].sortComparator as? KeyPathComparator<Value> else { return }
+        var order = sortOrder.wrappedValue
+        if let first = order.first as? KeyPathComparator<Value>, first.keyPath == column.keyPath {
+            column.order = first.order == .forward ? .reverse : .forward
+        }
+        order.removeAll { ($0 as? KeyPathComparator<Value>)?.keyPath == column.keyPath }
+        guard let sort = column as? Sort else { return }
+        order.insert(sort, at: 0)
+        sortOrder.wrappedValue = order
+    })
+}
+
+extension Table {
+    public init(
+        _ data: [Value], sortOrder: Binding<[KeyPathComparator<Value>]>, @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]> {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        _ data: [Value], sortOrder: Binding<[Sort]>, @TableColumnBuilder<Value, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]>, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection, Sort: SortComparator>(
+        _ data: Data, sortOrder: Binding<[Sort]>, @TableColumnBuilder<Data.Element, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<Data>, Data.Element == Value, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        _ data: [Value], selection: Binding<Value.ID?>, sortOrder: Binding<[KeyPathComparator<Value>]>,
+        @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]> {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        _ data: [Value], selection: Binding<Value.ID?>, sortOrder: Binding<[Sort]>,
+        @TableColumnBuilder<Value, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]>, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection, Sort: SortComparator>(
+        _ data: Data, selection: Binding<Value.ID?>, sortOrder: Binding<[Sort]>,
+        @TableColumnBuilder<Data.Element, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<Data>, Data.Element == Value, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        _ data: [Value], selection: Binding<Set<Value.ID>>, sortOrder: Binding<[KeyPathComparator<Value>]>,
+        @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]> {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        _ data: [Value], selection: Binding<Set<Value.ID>>, sortOrder: Binding<[Sort]>,
+        @TableColumnBuilder<Value, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<[Value]>, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection, Sort: SortComparator>(
+        _ data: Data, selection: Binding<Set<Value.ID>>, sortOrder: Binding<[Sort]>,
+        @TableColumnBuilder<Data.Element, Sort> columns: () -> Columns
+    ) where Rows == TableForEachContent<Data>, Data.Element == Value, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: ForEach(data) { TableRow($0) }, selection: selection,
+                  sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        sortOrder: Binding<[KeyPathComparator<Value>]>, @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns, @ViewBuilder rows: () -> Rows
+    ) where Rows: View {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        sortOrder: Binding<[Sort]>, @TableColumnBuilder<Value, Sort> columns: () -> Columns, @ViewBuilder rows: () -> Rows
+    ) where Rows: View, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        selection: Binding<Value.ID?>, sortOrder: Binding<[KeyPathComparator<Value>]>, @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), selection: selection, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        selection: Binding<Value.ID?>, sortOrder: Binding<[Sort]>, @TableColumnBuilder<Value, Sort> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), selection: selection, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        selection: Binding<Set<Value.ID>>, sortOrder: Binding<[KeyPathComparator<Value>]>, @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), selection: selection, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        selection: Binding<Set<Value.ID>>, sortOrder: Binding<[Sort]>, @TableColumnBuilder<Value, Sort> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View, Sort.Compared == Value {
+        let columns = columns()
+        self.init(_columns: columns, rows: rows(), selection: selection, sort: _tableSort(sortOrder, columns._tableColumns))
+    }
+
+    public init(
+        of valueType: Value.Type, sortOrder: Binding<[KeyPathComparator<Value>]>, @TableColumnBuilder<Value, KeyPathComparator<Value>> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View {
+        self.init(sortOrder: sortOrder, columns: columns, rows: rows)
+    }
+
+    @_disfavoredOverload
+    public init<Sort: SortComparator>(
+        of valueType: Value.Type, sortOrder: Binding<[Sort]>, @TableColumnBuilder<Value, Sort> columns: () -> Columns,
+        @ViewBuilder rows: () -> Rows
+    ) where Rows: View, Sort.Compared == Value {
+        self.init(sortOrder: sortOrder, columns: columns, rows: rows)
+    }
+}

package/Sources/FoundationBridge/TextAttributes.swift

@@ -0,0 +1,42 @@
+// The SwiftUI attributes of an `AttributedString`'s runs (`run.kern`,
+// `string[range].foregroundColor = .red`, …), which `Text(_:)` draws as the
+// matching `Text` modifiers (Links.swift). On Apple platforms they are
+// `AttributeScopes.SwiftUIAttributes`; here they extend Foundation's scope,
+// which is the one an attributed string's dynamic members look through.
+
+import Foundation
+import SwiftUI
+
+extension AttributeScopes.FoundationAttributes {
+    public enum KernAttribute: AttributedStringKey {
+        public typealias Value = SwiftUI.CGFloat
+        public static let name = "NSKern"
+    }
+
+    public enum TrackingAttribute: AttributedStringKey {
+        public typealias Value = SwiftUI.CGFloat
+        public static let name = "SwiftUI.Tracking"
+    }
+
+    public enum BaselineOffsetAttribute: AttributedStringKey {
+        public typealias Value = SwiftUI.CGFloat
+        public static let name = "NSBaselineOffset"
+    }
+
+    public enum ForegroundColorAttribute: AttributedStringKey {
+        public typealias Value = Color
+        public static let name = "SwiftUI.ForegroundColor"
+    }
+
+    public enum FontAttribute: AttributedStringKey {
+        public typealias Value = Font
+        public static let name = "SwiftUI.Font"
+    }
+
+    // Like the scope's own attributes, a key path names the key and its value is never read.
+    public var kern: KernAttribute { fatalError("an attribute key path is never read") }
+    public var tracking: TrackingAttribute { fatalError("an attribute key path is never read") }
+    public var baselineOffset: BaselineOffsetAttribute { fatalError("an attribute key path is never read") }
+    public var foregroundColor: ForegroundColorAttribute { fatalError("an attribute key path is never read") }
+    public var font: FontAttribute { fatalError("an attribute key path is never read") }
+}

package/Sources/FoundationBridge/Timer.swift

@@ -0,0 +1,53 @@
+// `Timer` and `RunLoop` for full-Foundation apps in the browser. swift-corelibs
+// Foundation marks `RunLoop` unavailable on WASI and its `Timer` needs
+// CFRunLoop, which the WASI build does not have (the link fails), and
+// `Timer.publish` is Combine's anyway. These two classes have the same names;
+// the CLI's staging gives the app `typealias Timer = FoundationBridge.Timer`
+// and `typealias RunLoop = FoundationBridge.RunLoop`, so `Timer.publish(every:
+// 1, on: .main, in: .common).autoconnect()` and `Timer.scheduledTimer` resolve
+// here. Ticks come from the runtime's executor (`_IntervalPublisher` and
+// `_ExecutorTimer` in the SwiftUI shim), so headless runs stay deterministic.
+
+import Foundation
+import SwiftUI
+
+public final class RunLoop: @unchecked Sendable {
+    public struct Mode: Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let `default` = Mode(rawValue: "default")
+        public static let common = Mode(rawValue: "common")
+    }
+    nonisolated(unsafe) public static let main = RunLoop()
+    public static var current: RunLoop { main }
+
+    /// Timers run as soon as they are made; adding one changes nothing.
+    public func add(_ timer: Timer, forMode mode: Mode) {}
+}
+
+public final class Timer: @unchecked Sendable {
+    /// Emits the current date every `interval` seconds once subscribed.
+    public typealias TimerPublisher = _IntervalPublisher<Date>
+
+    public static func publish(every interval: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop = .main, in mode: RunLoop.Mode = .default, options: Never? = nil) -> TimerPublisher {
+        _IntervalPublisher(every: interval) { Date() }
+    }
+
+    private var core: _ExecutorTimer!
+    /// What the timer was made with (`scheduledTimer(timeInterval:target:selector:userInfo:repeats:)`).
+    public internal(set) var userInfo: Any?
+
+    public var isValid: Bool { core.isValid }
+    public var timeInterval: TimeInterval { core.timeInterval }
+
+    init(interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) {
+        core = _ExecutorTimer(interval: interval, repeats: repeats) { _ in block(self) }
+    }
+
+    @discardableResult
+    public static func scheduledTimer(withTimeInterval interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) -> Timer {
+        Timer(interval: interval, repeats: repeats, block: block)
+    }
+
+    public func invalidate() { core.invalidate() }
+}

package/Sources/FoundationBridge/UITextChecker.swift

@@ -0,0 +1,30 @@
+// A stand-in for UIKit's `UITextChecker`, which SwiftUI apps reach through
+// SwiftUI's re-export of UIKit (Hacking with SwiftUI's WordScramble checks
+// spelling with it). Full-Foundation builds only (NSRange is Foundation's). The
+// browser has no spell checker to ask, so every word
+// passes: `rangeOfMisspelledWord` is always `NSNotFound`, `guesses` and
+// `completions` are nil. Enough for the code to compile and run; the game
+// just stops rejecting misspellings.
+
+import Foundation
+
+public final class UITextChecker: @unchecked Sendable {
+    public init() {}
+
+    /// Always "no misspelling": `NSRange(location: NSNotFound, length: 0)`.
+    public func rangeOfMisspelledWord(in stringToCheck: String, range: NSRange, startingAt startingOffset: Int,
+                                      wrap wrapFlag: Bool, language: String) -> NSRange {
+        NSRange(location: NSNotFound, length: 0)
+    }
+
+    public func guesses(forWordRange range: NSRange, in string: String, language: String) -> [String]? { nil }
+    public func completions(forPartialWordRange range: NSRange, in string: String, language: String) -> [String]? { nil }
+
+    public static let availableLanguages: [String] = ["en"]
+    public static func hasLearnedWord(_ word: String) -> Bool { false }
+    public static func learnWord(_ word: String) {}
+    public static func unlearnWord(_ word: String) {}
+    public func ignoreWord(_ wordToIgnore: String) {}
+    public func ignoredWords() -> [String]? { nil }
+    public func setIgnoredWords(_ words: [String]?) {}
+}