@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/FoundationBridge/NotificationCenter.swift

@@ -0,0 +1,154 @@
+// `NotificationCenter` with the API apps and packages use. On WASI, Swift
+// 6.4's Foundation keeps only the new message-based center: no
+// `addObserver(forName:object:queue:using:)`, no `post(name:object:)`, and no
+// selectors. So code that observes notifications type-checks on the host and
+// fails to build for the browser. This class is the classic center, and the
+// CLI's staging aliases it into every module (like `Timer`), so the host
+// check and the browser build use the same one.
+//
+// The page has one thread: observers run synchronously when a notification
+// is posted, whatever queue they were added with. (Foundation runs a queue's
+// observer on that queue and waits for it, which has the same effect here.)
+
+import Foundation
+import SwiftUI
+
+open class NotificationCenter: @unchecked Sendable {
+    public static let `default` = NotificationCenter()
+
+    public init() {}
+
+    /// What `addObserver(forName:object:queue:using:)` returns; pass it to `removeObserver`.
+    final class Observation: NSObject, @unchecked Sendable {
+        let name: Notification.Name?
+        weak var object: AnyObject?
+        let hasObject: Bool
+        let block: (Notification) -> Void
+        /// For a selector observer: the observer, held weakly.
+        weak var observer: AnyObject?
+        let observes: Bool
+
+        init(name: Notification.Name?, object: Any?, observer: AnyObject?, block: @escaping (Notification) -> Void) {
+            self.name = name
+            self.object = object.map { $0 as AnyObject }
+            hasObject = object != nil
+            self.observer = observer
+            observes = observer != nil
+            self.block = block
+        }
+
+        func matches(_ notification: Notification) -> Bool {
+            if let name, name != notification.name { return false }
+            if hasObject {
+                guard let object, let sender = notification.object.map({ $0 as AnyObject }), sender === object else { return false }
+            }
+            return true
+        }
+    }
+
+    private var observations: [Observation] = []
+
+    // MARK: Observing
+
+    @discardableResult
+    open func addObserver(forName name: Notification.Name?, object obj: Any?, queue: OperationQueue?, using block: @escaping @Sendable (Notification) -> Void) -> any NSObjectProtocol {
+        let observation = Observation(name: name, object: obj, observer: nil, block: block)
+        observations.append(observation)
+        return observation
+    }
+
+    /// Calls `selector` on `observer` for each matching notification. The
+    /// observer is held weakly, as on iOS 9 and later: once it is gone, the
+    /// observation ends.
+    open func addObserver(_ observer: Any, selector aSelector: Selector, name aName: Notification.Name?, object anObject: Any?) {
+        let target = observer as AnyObject
+        let observation = Observation(name: aName, object: anObject, observer: target) { [weak target] note in
+            if let target { aSelector._perform(on: target, with: note) }
+        }
+        observations.append(observation)
+    }
+
+    /// The matching notifications, as they are posted.
+    public func notifications(named name: Notification.Name, object: AnyObject? = nil) -> Notifications {
+        Notifications(center: self, name: name, object: object)
+    }
+
+    /// For `onReceive(NotificationCenter.default.publisher(for: …))`.
+    public func publisher(for name: Notification.Name, object: AnyObject? = nil) -> Publisher {
+        Publisher(center: self, name: name, object: object)
+    }
+
+    // MARK: Removing
+
+    /// Removes an observation token, or every selector observation of an observer.
+    open func removeObserver(_ observer: Any) {
+        let target = observer as AnyObject
+        observations.removeAll { $0 === target || ($0.observes && $0.observer === target) }
+    }
+
+    open func removeObserver(_ observer: Any, name aName: Notification.Name?, object anObject: Any?) {
+        let target = observer as AnyObject
+        let sender = anObject.map { $0 as AnyObject }
+        observations.removeAll { observation in
+            guard observation === target || (observation.observes && observation.observer === target) else { return false }
+            if let aName, observation.name != aName { return false }
+            if let sender, observation.object !== sender { return false }
+            return true
+        }
+    }
+
+    // MARK: Posting
+
+    open func post(_ notification: Notification) {
+        // Observers that are gone end their observations.
+        observations.removeAll { $0.observes && $0.observer == nil }
+        for observation in observations where observation.matches(notification) {
+            observation.block(notification)
+        }
+    }
+
+    open func post(name aName: Notification.Name, object anObject: Any?, userInfo aUserInfo: [AnyHashable: Any]? = nil) {
+        post(Notification(name: aName, object: anObject, userInfo: aUserInfo))
+    }
+
+    // MARK: Sequences and publishers
+
+    public struct Notifications: AsyncSequence, @unchecked Sendable {
+        public typealias Element = Notification
+        let center: NotificationCenter
+        let name: Notification.Name
+        let object: AnyObject?
+
+        public func makeAsyncIterator() -> AsyncStream<Notification>.Iterator {
+            let (stream, continuation) = AsyncStream<Notification>.makeStream()
+            nonisolated(unsafe) let token = center.addObserver(forName: name, object: object, queue: nil) { note in
+                nonisolated(unsafe) let note = note
+                continuation.yield(note)
+            }
+            let center = self.center
+            continuation.onTermination = { _ in center.removeObserver(token) }
+            return stream.makeAsyncIterator()
+        }
+    }
+
+    public struct Publisher: _Publisher, @unchecked Sendable {
+        public typealias Output = Notification
+        public let center: NotificationCenter
+        public let name: Notification.Name
+        public let object: AnyObject?
+
+        @MainActor public func _subscribe(_ receive: @escaping @MainActor (Notification) -> Void) -> any _Cancellable {
+            let token = center.addObserver(forName: name, object: object, queue: nil) { note in
+                nonisolated(unsafe) let note = note
+                MainActor.assumeIsolated { receive(note) }
+            }
+            return _NotificationCancellable(center: center, token: token)
+        }
+    }
+}
+
+struct _NotificationCancellable: _Cancellable, @unchecked Sendable {
+    let center: NotificationCenter
+    let token: any NSObjectProtocol
+    func cancel() { center.removeObserver(token) }
+}

package/Sources/FoundationBridge/OpenURLHandlers.swift

@@ -0,0 +1,60 @@
+// `onOpenURL`: the app's own URL schemes, opened from inside the app. On iOS
+// a URL in a scheme the app declares (CFBundleURLTypes) launches the app and
+// reaches its `onOpenURL` handlers. In the browser nothing outside the page
+// can open such a URL, but the app itself can: a link or `openURL` call (and
+// `UIApplication.open`) with `myapp://…` goes to the handlers of the views on
+// screen instead of the page, which could not open it. The schemes are the
+// ones signing in uses (`SB_URL_SCHEMES`; WebAuthRedirects.swift). Universal
+// links and `NSUserActivity` continuation are not delivered.
+
+import Foundation
+import SwiftUI
+
+/// The `onOpenURL` actions of the views on screen, in the order they appeared.
+@MainActor
+public enum _OpenURLHandlers {
+    final class Token {}
+
+    static var handlers: [(token: ObjectIdentifier, action: (URL) -> Void)] = []
+
+    static func set(_ token: Token, _ action: @escaping (URL) -> Void) {
+        let id = ObjectIdentifier(token)
+        if let index = handlers.firstIndex(where: { $0.token == id }) {
+            handlers[index].action = action
+        } else {
+            handlers.append((id, action))
+        }
+    }
+
+    static func remove(_ token: Token) {
+        handlers.removeAll { $0.token == ObjectIdentifier(token) }
+    }
+
+    /// Hands `url` to every handler when it is in one of the app's schemes and
+    /// some view handles URLs; false otherwise (the caller opens it as usual).
+    public static func deliver(_ url: URL) -> Bool {
+        guard !handlers.isEmpty, _WebAuthRedirects.isAppRedirect(url.absoluteString) else { return false }
+        for handler in handlers { handler.action(url) }
+        return true
+    }
+}
+
+private struct _OpenURLModifier: ViewModifier {
+    let action: (URL) -> Void
+    @State private var token = _OpenURLHandlers.Token()
+
+    func body(content: Content) -> some View {
+        let token = token, action = action
+        return content
+            .onAppear { _OpenURLHandlers.set(token, action) }
+            .onDisappear { _OpenURLHandlers.remove(token) }
+    }
+}
+
+extension View {
+    /// Calls `action` with each URL in one of the app's own schemes that the
+    /// app opens while this view is on screen (see the top of this file).
+    public func onOpenURL(perform action: @escaping (URL) -> Void) -> some View {
+        modifier(_OpenURLModifier(action: action))
+    }
+}

package/Sources/FoundationBridge/Operation.swift

@@ -0,0 +1,195 @@
+// `Operation` and `OperationQueue` for the browser. The WASI SDK's
+// Foundation has neither (they need Dispatch). The page has one thread, so a
+// queue runs its operations on the main actor, one at a time, in the order
+// they were added, each on a later turn than the one that added it; that is
+// what a serial queue (`maxConcurrentOperationCount = 1`, or the main queue)
+// promises, and a concurrent queue's work cannot overlap anyway. An
+// asynchronous operation (one that overrides `start()`, `isExecuting` and
+// `isFinished`) finishes later: it says so with
+// `didChangeValue(forKey: "isFinished")`, as it does for key-value observing
+// on Apple platforms, and that runs its completion block and lets a serial
+// queue go on to the next operation. The CLI's
+// staging aliases the names to these (the host's Foundation has its own), so
+// `check` type-checks what the browser runs.
+
+import Foundation
+
+/// A unit of work.
+open class Operation: @unchecked Sendable {
+    public enum QueuePriority: Int, Sendable {
+        case veryLow = -8, low = -4, normal = 0, high = 4, veryHigh = 8
+    }
+
+    private var _isCancelled = false
+    private var _isExecuting = false
+    private var _isFinished = false
+
+    // Open, as in Foundation: an asynchronous operation overrides them with
+    // its own state (and calls `willChangeValue`/`didChangeValue` around it).
+    open var isCancelled: Bool { _isCancelled }
+    open var isExecuting: Bool { _isExecuting }
+    open var isFinished: Bool { _isFinished }
+    open var isAsynchronous: Bool { false }
+    open var isReady: Bool { dependencies.allSatisfy(\.isFinished) }
+    public var queuePriority: QueuePriority = .normal
+    public var name: String?
+    public var completionBlock: (@Sendable () -> Void)?
+    /// Accepted and ignored: everything runs on the main actor.
+    public var qualityOfService: QualityOfService = .default
+    public private(set) var dependencies: [Operation] = []
+
+    /// The queue running it, told when it finishes.
+    fileprivate weak var queue: OperationQueue?
+    private var completed = false
+
+    public init() {}
+
+    /// The work. Subclasses override it.
+    open func main() {}
+
+    /// Runs `main()` unless cancelled, then the completion block. An
+    /// operation that keeps its own `isFinished` (an asynchronous one whose
+    /// `main()` starts work that ends later) is finished when that says so:
+    /// at its `didChangeValue(forKey: "isFinished")`, as a queue on Apple
+    /// platforms waits for that key-value notification.
+    open func start() {
+        guard !isFinished else { return }
+        if !isCancelled {
+            _isExecuting = true
+            main()
+            _isExecuting = false
+        }
+        _isFinished = true
+        if isFinished { finished() }
+    }
+
+    /// Runs the completion block and tells the queue, once.
+    private func finished() {
+        guard !completed else { return }
+        completed = true
+        completionBlock?()
+        queue?.operationFinished(self)
+    }
+
+    open func cancel() { _isCancelled = true }
+
+    /// Key-value observing's change notifications, which an asynchronous
+    /// operation sends around its changes to `isExecuting` and `isFinished`.
+    /// The change to `isFinished` finishes it (completion block, queue); the
+    /// others have nothing observing them.
+    public func willChangeValue(forKey key: String) {}
+    public func didChangeValue(forKey key: String) {
+        if key == "isFinished", isFinished { finished() }
+    }
+
+    public func addDependency(_ operation: Operation) { dependencies.append(operation) }
+    public func removeDependency(_ operation: Operation) { dependencies.removeAll { $0 === operation } }
+
+    /// Returns at once: with one thread, the operation either ran already or cannot run while this waits.
+    public func waitUntilFinished() {}
+}
+
+/// Runs closures.
+open class BlockOperation: Operation, @unchecked Sendable {
+    public private(set) var executionBlocks: [@Sendable () -> Void] = []
+
+    public override init() {}
+
+    public convenience init(block: @escaping @Sendable () -> Void) {
+        self.init()
+        executionBlocks = [block]
+    }
+
+    public func addExecutionBlock(_ block: @escaping @Sendable () -> Void) { executionBlocks.append(block) }
+
+    open override func main() {
+        for block in executionBlocks { block() }
+    }
+}
+
+/// Runs operations on the main actor, in order.
+open class OperationQueue: @unchecked Sendable {
+    public static let defaultMaxConcurrentOperationCount = -1
+
+    nonisolated(unsafe) public static let main: OperationQueue = {
+        let queue = OperationQueue()
+        queue.name = "NSOperationQueue Main Queue"
+        queue.maxConcurrentOperationCount = 1
+        return queue
+    }()
+
+    /// The queue running the current operation: the main queue (everything runs there).
+    public static var current: OperationQueue? { main }
+
+    public var name: String?
+    /// Accepted and ignored: everything runs on the main actor.
+    public var qualityOfService: QualityOfService = .default
+    public var maxConcurrentOperationCount = OperationQueue.defaultMaxConcurrentOperationCount
+    public var underlyingQueue: DispatchQueue?
+    public var isSuspended = false {
+        didSet { if !isSuspended { drain() } }
+    }
+
+    private var pending: [Operation] = []
+    /// Asynchronous operations started and not yet finished.
+    private var running: [Operation] = []
+    private var scheduled = false
+
+    public init() {}
+
+    public var operations: [Operation] { running + pending }
+    public var operationCount: Int { running.count + pending.count }
+
+    public func addOperation(_ operation: Operation) {
+        pending.append(operation)
+        schedule()
+    }
+
+    public func addOperation(_ block: @escaping @Sendable () -> Void) {
+        addOperation(BlockOperation(block: block))
+    }
+
+    public func addOperations(_ operations: [Operation], waitUntilFinished wait: Bool) {
+        pending += operations
+        schedule()
+    }
+
+    /// Runs `block` after every operation added before it.
+    public func addBarrierBlock(_ block: @escaping @Sendable () -> Void) {
+        addOperation(block)
+    }
+
+    public func cancelAllOperations() {
+        for operation in running + pending { operation.cancel() }
+    }
+
+    /// Returns at once: the operations run on later turns of the main actor.
+    public func waitUntilAllOperationsAreFinished() {}
+
+    private func schedule() {
+        guard !scheduled, !isSuspended else { return }
+        scheduled = true
+        nonisolated(unsafe) let queue = self
+        Task { @MainActor in
+            queue.scheduled = false
+            queue.drain()
+        }
+    }
+
+    private func drain() {
+        // A serial queue waits for an asynchronous operation to finish.
+        while !isSuspended, maxConcurrentOperationCount != 1 || running.isEmpty,
+              let index = pending.firstIndex(where: \.isReady) {
+            let operation = pending.remove(at: index)
+            operation.queue = self
+            operation.start()
+            if !operation.isFinished { running.append(operation) }
+        }
+    }
+
+    fileprivate func operationFinished(_ operation: Operation) {
+        guard let index = running.firstIndex(where: { $0 === operation }) else { return }
+        running.remove(at: index)
+        schedule()
+    }
+}

package/Sources/FoundationBridge/ProcessInfo.swift

@@ -0,0 +1,32 @@
+// `ProcessInfo.processInfo.physicalMemory` for the browser. swift-foundation
+// answers 0 on WASI, and libraries size their limits from it (Nuke refuses
+// any download larger than a tenth of it, so every image would fail). The
+// getter is reached through the class's vtable, out of a linker's reach, so
+// the CLI's staging rewrites the expression to `_physicalMemory`: 4 GiB in the
+// browser, the most a wasm32 module can address (Nuke's own cap, 200 MB, then
+// applies as on a phone), and Foundation's answer elsewhere.
+
+import Foundation
+
+public var _physicalMemory: UInt64 {
+    #if os(WASI)
+    4 * 1024 * 1024 * 1024
+    #else
+    ProcessInfo.processInfo.physicalMemory
+    #endif
+}
+
+extension ProcessInfo {
+    /// The browser is no Mac: an iOS app here runs as on an iPhone.
+    public var isiOSAppOnMac: Bool { false }
+    public var isMacCatalystApp: Bool { false }
+    /// The page cannot read the battery's saver: never on, so animations run.
+    public var isLowPowerModeEnabled: Bool { false }
+}
+
+/// Darwin's `sysctlbyname`, which apps call for the hardware model. The browser
+/// has no kernel to ask: every name is unknown (-1, nothing written).
+public func sysctlbyname(_ name: UnsafePointer<CChar>?, _ oldp: UnsafeMutableRawPointer?, _ oldlenp: UnsafeMutablePointer<Int>?, _ newp: UnsafeMutableRawPointer?, _ newlen: Int) -> Int32 {
+    oldlenp?.pointee = 0
+    return -1
+}

package/Sources/FoundationBridge/RelativeDateTimeFormatter.swift

@@ -0,0 +1,136 @@
+// `RelativeDateTimeFormatter` ("2 hr. ago", "in 3 days"), which corelibs
+// Foundation does not have. English only, like the rest of the bridge's
+// formatting: the largest unit with a nonzero amount, counted as Apple's
+// does (weeks of 7 days, months of 30 and years of 365, rounded toward zero).
+
+import Foundation
+
+open class RelativeDateTimeFormatter: @unchecked Sendable {
+    public enum DateTimeStyle: Int, Sendable {
+        case numeric = 0
+        case named = 1
+    }
+
+    public enum UnitsStyle: Int, Sendable {
+        case full = 0
+        case spellOut = 1
+        case short = 2
+        case abbreviated = 3
+    }
+
+    /// How the string will be used; the bridge's English has no capitalization rules to apply.
+    public enum Context: Int, Sendable {
+        case unknown = 0
+        case dynamic = 1
+        case standalone = 2
+        case listItem = 3
+        case beginningOfSentence = 4
+        case middleOfSentence = 5
+    }
+
+    open var dateTimeStyle: DateTimeStyle = .numeric
+    open var unitsStyle: UnitsStyle = .full
+    open var formattingContext: Context = .unknown
+    open var calendar: Calendar! = .current
+    open var locale: Locale! = .current
+
+    public init() {}
+
+    open func localizedString(for date: Date, relativeTo referenceDate: Date) -> String {
+        localizedString(fromTimeInterval: date.timeIntervalSince(referenceDate))
+    }
+
+    open func localizedString(fromTimeInterval timeInterval: TimeInterval) -> String {
+        let seconds = Int(timeInterval.rounded(.towardZero))
+        let magnitude = abs(seconds)
+        let (amount, unit): (Int, _Unit) = switch magnitude {
+        case ..<60: (magnitude, .second)
+        case ..<3_600: (magnitude / 60, .minute)
+        case ..<86_400: (magnitude / 3_600, .hour)
+        case ..<604_800: (magnitude / 86_400, .day)
+        case ..<2_592_000: (magnitude / 604_800, .week)
+        case ..<31_536_000: (magnitude / 2_592_000, .month)
+        default: (magnitude / 31_536_000, .year)
+        }
+        return phrase(amount, unit, future: seconds >= 0)
+    }
+
+    open func localizedString(from dateComponents: DateComponents) -> String {
+        let parts: [(Int?, _Unit)] = [
+            (dateComponents.year, .year), (dateComponents.month, .month), (dateComponents.weekOfMonth, .week),
+            (dateComponents.day, .day), (dateComponents.hour, .hour), (dateComponents.minute, .minute),
+            (dateComponents.second, .second),
+        ]
+        let (value, unit) = parts.first { ($0.0 ?? 0) != 0 }.map { ($0.0!, $0.1) } ?? (0, .second)
+        return phrase(abs(value), unit, future: value >= 0)
+    }
+
+    open func string(for obj: Any?) -> String? {
+        guard let date = obj as? Date else { return nil }
+        return localizedString(for: date, relativeTo: Date())
+    }
+
+    enum _Unit { case second, minute, hour, day, week, month, year }
+
+    func phrase(_ amount: Int, _ unit: _Unit, future: Bool) -> String {
+        if dateTimeStyle == .named, let named = named(amount, unit, future: future) { return named }
+        let count = unitsStyle == .spellOut ? Self.spelled(amount) : String(amount)
+        let quantity: String
+        switch unitsStyle {
+        case .abbreviated:
+            let suffix = switch unit {
+            case .second: "s"
+            case .minute: "m"
+            case .hour: "h"
+            case .day: "d"
+            case .week: "w"
+            case .month: "mo"
+            case .year: "y"
+            }
+            quantity = count + suffix
+        case .short:
+            let word = switch unit {
+            case .second: "sec."
+            case .minute: "min."
+            case .hour: "hr."
+            case .day: amount == 1 ? "day" : "days"
+            case .week: "wk."
+            case .month: "mo."
+            case .year: "yr."
+            }
+            quantity = "\(count) \(word)"
+        case .full, .spellOut:
+            let word = switch unit {
+            case .second: "second"
+            case .minute: "minute"
+            case .hour: "hour"
+            case .day: "day"
+            case .week: "week"
+            case .month: "month"
+            case .year: "year"
+            }
+            quantity = "\(count) \(word)\(amount == 1 ? "" : "s")"
+        }
+        return future ? "in \(quantity)" : "\(quantity) ago"
+    }
+
+    /// "now", "yesterday", "next week" and the like, for the named style.
+    func named(_ amount: Int, _ unit: _Unit, future: Bool) -> String? {
+        if amount == 0 { return unit == .second ? "now" : "this \(unit)" }
+        guard amount == 1 else { return nil }
+        switch unit {
+        case .second, .minute, .hour: return nil
+        case .day: return future ? "tomorrow" : "yesterday"
+        default: return "\(future ? "next" : "last") \(unit)"
+        }
+    }
+
+    static func spelled(_ n: Int) -> String {
+        let ones = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven",
+                    "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]
+        let tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]
+        if n < 20 { return ones[n] }
+        if n < 100 { return tens[n / 10] + (n % 10 == 0 ? "" : "-" + ones[n % 10]) }
+        return String(n)
+    }
+}

package/Sources/FoundationBridge/SceneStorage.swift

@@ -0,0 +1,78 @@
+// `@SceneStorage`: a view property the scene restores. The page is one
+// scene, restored when it reloads, so a scene-stored value is an
+// `@AppStorage` value under a key of its own (`SceneStorage.<key>`): it
+// survives reloads and re-renders the views that read it when it changes.
+
+import Foundation
+import SwiftUI
+
+@propertyWrapper
+public struct SceneStorage<Value>: DynamicProperty {
+    let storage: AppStorage<Value>
+
+    init(_ storage: AppStorage<Value>) { self.storage = storage }
+
+    public var wrappedValue: Value {
+        get { storage.wrappedValue }
+        nonmutating set { storage.wrappedValue = newValue }
+    }
+
+    public var projectedValue: Binding<Value> { storage.projectedValue }
+
+    static func key(_ key: String) -> String { "SceneStorage." + key }
+}
+
+extension SceneStorage {
+    public init(wrappedValue: Value, _ key: String) where Value == Bool {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == Int {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == Double {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == String {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == URL {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == Data {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value == Date {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value: RawRepresentable, Value.RawValue == Int {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+    public init(wrappedValue: Value, _ key: String) where Value: RawRepresentable, Value.RawValue == String {
+        self.init(AppStorage(wrappedValue: wrappedValue, Self.key(key)))
+    }
+}
+
+/// The optional forms: nil when nothing is stored.
+extension SceneStorage where Value: ExpressibleByNilLiteral {
+    public init(_ key: String) where Value == Bool? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == Int? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == Double? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == String? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == URL? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == Data? {
+        self.init(AppStorage(Self.key(key)))
+    }
+    public init(_ key: String) where Value == Date? {
+        self.init(AppStorage(Self.key(key)))
+    }
+}

package/Sources/FoundationBridge/SecurityExports.swift

@@ -0,0 +1,8 @@
+// On Apple platforms Foundation brings parts of Security along (its headers
+// import it), so code that imports only Foundation calls
+// `SecRandomCopyBytes` (Ice Cubes makes its push-notification auth key that
+// way). These come from the shim's Security module.
+
+@_exported import func Security.SecRandomCopyBytes
+@_exported import var Security.kSecRandomDefault
+@_exported import typealias Security.SecRandomRef