@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/FoundationBridge/AppStorage.swift

@@ -0,0 +1,165 @@
+// `@AppStorage`: a view property kept in `UserDefaults` (UserDefaults.swift),
+// so it survives reloads like the rest of the app's defaults. It lives here
+// rather than in the SwiftUI shim because the shim's `UserDefaults` does.
+//
+// A read registers with the observation tracking the runtime runs each body
+// under, and every write to the key (through any `@AppStorage`, or
+// `UserDefaults.set` itself) is a mutation of it: the views that read the key
+// re-render, and nothing else does.
+
+import Foundation
+import Observation
+import SwiftUI
+
+/// A property that reads and writes a `UserDefaults` value and re-renders the
+/// view when it changes, as SwiftUI's does.
+@propertyWrapper
+public struct AppStorage<Value>: DynamicProperty {
+    let key: String
+    let defaultValue: Value
+    let store: UserDefaults
+    let read: (UserDefaults, String) -> Value?
+    let write: (UserDefaults, String, Value) -> Void
+
+    init(key: String, defaultValue: Value, store: UserDefaults?,
+         read: @escaping (UserDefaults, String) -> Value?,
+         write: @escaping (UserDefaults, String, Value) -> Void) {
+        self.key = key
+        self.defaultValue = defaultValue
+        self.store = store ?? .standard
+        self.read = read
+        self.write = write
+    }
+
+    public var wrappedValue: Value {
+        get {
+            _DefaultsKey.named(key).access()
+            guard store.object(forKey: key) != nil else { return defaultValue }
+            return read(store, key) ?? defaultValue
+        }
+        nonmutating set { write(store, key, newValue) }
+    }
+
+    public var projectedValue: Binding<Value> {
+        let storage = self
+        return Binding(get: { storage.wrappedValue }, set: { storage.wrappedValue = $0 })
+    }
+}
+
+/// Reads a stored value as `T`: the property-list types as `UserDefaults`
+/// keeps them, accepting what a reload hands back (JSON numbers come back as
+/// `Int` when whole).
+private func _stored<T>(_ type: T.Type, _ store: UserDefaults, _ key: String) -> T? {
+    switch type {
+    case is Bool.Type: return store.bool(forKey: key) as? T
+    case is Int.Type: return store.integer(forKey: key) as? T
+    case is Double.Type: return store.double(forKey: key) as? T
+    case is String.Type: return store.string(forKey: key) as? T
+    case is URL.Type: return store.url(forKey: key) as? T
+    default: return store.object(forKey: key) as? T
+    }
+}
+
+private func _plain<T>(_: T.Type) -> (UserDefaults, String) -> T? {
+    { store, key in _stored(T.self, store, key) }
+}
+
+private func _plainWrite<T>(_: T.Type) -> (UserDefaults, String, T) -> Void {
+    { store, key, value in store.set(value as Any, forKey: key) }
+}
+
+private func _optional<T>(_: T.Type) -> (UserDefaults, String) -> T?? {
+    { store, key in _stored(T.self, store, key).map { .some($0) } }
+}
+
+private func _optionalWrite<T>(_: T.Type) -> (UserDefaults, String, T?) -> Void {
+    { store, key, value in
+        if let value { store.set(value as Any, forKey: key) } else { store.removeObject(forKey: key) }
+    }
+}
+
+extension AppStorage {
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == Bool {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(Bool.self), write: _plainWrite(Bool.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == Int {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(Int.self), write: _plainWrite(Int.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == Double {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(Double.self), write: _plainWrite(Double.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == String {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(String.self), write: _plainWrite(String.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == URL {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(URL.self), write: _plainWrite(URL.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == Data {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(Data.self), write: _plainWrite(Data.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil) where Value == Date {
+        self.init(key: key, defaultValue: wrappedValue, store: store, read: _plain(Date.self), write: _plainWrite(Date.self))
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil)
+    where Value: RawRepresentable, Value.RawValue == Int {
+        self.init(key: key, defaultValue: wrappedValue, store: store,
+                  read: { store, key in Value(rawValue: store.integer(forKey: key)) },
+                  write: { store, key, value in store.set(value.rawValue, forKey: key) })
+    }
+    public init(wrappedValue: Value, _ key: String, store: UserDefaults? = nil)
+    where Value: RawRepresentable, Value.RawValue == String {
+        self.init(key: key, defaultValue: wrappedValue, store: store,
+                  read: { store, key in store.string(forKey: key).flatMap(Value.init(rawValue:)) },
+                  write: { store, key, value in store.set(value.rawValue, forKey: key) })
+    }
+}
+
+/// The optional forms: nil when nothing is stored, and assigning nil removes
+/// the key.
+extension AppStorage where Value: ExpressibleByNilLiteral {
+    public init(_ key: String, store: UserDefaults? = nil) where Value == Bool? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(Bool.self), write: _optionalWrite(Bool.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == Int? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(Int.self), write: _optionalWrite(Int.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == Double? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(Double.self), write: _optionalWrite(Double.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == String? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(String.self), write: _optionalWrite(String.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == URL? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(URL.self), write: _optionalWrite(URL.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == Data? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(Data.self), write: _optionalWrite(Data.self))
+    }
+    public init(_ key: String, store: UserDefaults? = nil) where Value == Date? {
+        self.init(key: key, defaultValue: nil, store: store, read: _optional(Date.self), write: _optionalWrite(Date.self))
+    }
+}
+
+/// One defaults key as something observation tracking can watch.
+final class _DefaultsKey: Observable, @unchecked Sendable {
+    nonisolated(unsafe) private static var keys: [String: _DefaultsKey] = [:]
+
+    static func named(_ key: String) -> _DefaultsKey {
+        if let known = keys[key] { return known }
+        let made = _DefaultsKey()
+        keys[key] = made
+        return made
+    }
+
+    /// Every key some view has read, for a change that touches them all.
+    static var all: [_DefaultsKey] { Array(keys.values) }
+
+    private let registrar = ObservationRegistrar()
+    private var version = 0
+
+    func access() { registrar.access(self, keyPath: \.version) }
+
+    func changed() {
+        registrar.withMutation(of: self, keyPath: \.version) { version &+= 1 }
+    }
+}

package/Sources/FoundationBridge/AssetResources.swift

@@ -0,0 +1,90 @@
+// Asset catalog resources (iOS 17): `ImageResource` and `ColorResource`,
+// which Xcode generates a static member of for each image and color set
+// (`Image(.avatar)`, `Color(.accent)`), and which packages take as
+// parameters. They name a catalog entry and the bundle it is in. The page's
+// asset catalog is the whole app's (docs/ops-protocol.md, "Phase 5"), so a
+// resource draws as the catalog image or color of its name, whichever
+// bundle it names.
+
+import SwiftUI
+
+/// An image set of an asset catalog.
+public struct ImageResource: Hashable, Sendable {
+    public let name: String
+    let bundlePath: String
+
+    public init(name: String, bundle: Bundle) {
+        self.name = name
+        bundlePath = bundle.bundlePath
+    }
+}
+
+/// A color set of an asset catalog.
+public struct ColorResource: Hashable, Sendable {
+    public let name: String
+    let bundlePath: String
+
+    public init(name: String, bundle: Bundle) {
+        self.name = name
+        bundlePath = bundle.bundlePath
+    }
+}
+
+extension Image {
+    /// The catalog image `resource` names.
+    public init(_ resource: ImageResource) {
+        self.init(resource.name)
+    }
+
+    /// The catalog image `resource` names, hidden from assistive technology.
+    public init(decorative resource: ImageResource) {
+        self.init(decorative: resource.name)
+    }
+
+    /// The catalog image `name`, from any bundle (a package's `.module`):
+    /// the page's catalog is the whole app's.
+    public init(_ name: String, bundle: Bundle?) {
+        self.init(name)
+    }
+
+    public init(decorative name: String, bundle: Bundle?) {
+        self.init(decorative: name)
+    }
+}
+
+extension Color {
+    /// The catalog color `resource` names (light and dark resolved by the page).
+    ///
+    /// Disfavored: a color set named like a UIKit color (Ice Cubes'
+    /// `label`, a reference to the system label color) makes `.label` a
+    /// member of both `ColorResource` and `UIColor`, and `Color(.label)`
+    /// means the system color, which such a set refers to anyway.
+    @_disfavoredOverload
+    public init(_ resource: ColorResource) {
+        self.init(resource.name)
+    }
+
+    /// The catalog color `name`, from any bundle (as `Image(_:bundle:)`).
+    public init(_ name: String, bundle: Bundle?) {
+        self.init(name)
+    }
+}
+
+extension Label where Title == Text, Icon == Image {
+    /// A label whose icon is the catalog image `resource` names.
+    public init(_ titleKey: LocalizedStringKey, image resource: ImageResource) {
+        self.init(titleKey, image: resource.name)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image resource: ImageResource) {
+        self.init(title, image: resource.name)
+    }
+}
+
+extension UIImage {
+    /// The catalog image `resource` names (its size is the page's to know, as for `UIImage(named:)`).
+    public convenience init(resource: ImageResource) {
+        self.init(named: resource.name)!
+    }
+}

package/Sources/FoundationBridge/AsyncBytes.swift

@@ -0,0 +1,128 @@
+// Bytes and lines as async sequences, which Foundation has on Apple platforms
+// and corelibs Foundation does not: `FileHandle.bytes`, `URLSession`'s
+// `bytes(for:)` and `bytes(from:)`, and `.lines` on any sequence of bytes.
+// A file's bytes are read in chunks as the sequence is iterated; a response's
+// arrive whole (the page's `fetch` answers with the body), then are handed out
+// one by one.
+
+import Foundation
+
+/// The lines of a sequence of UTF-8 bytes: split at `\n`, `\r\n` and `\r`,
+/// without the separators. A last line without a separator is a line; an
+/// empty one after the last separator is not.
+public struct AsyncLineSequence<Base: AsyncSequence>: AsyncSequence where Base.Element == UInt8 {
+    public typealias Element = String
+
+    let base: Base
+
+    public struct AsyncIterator: AsyncIteratorProtocol {
+        var base: Base.AsyncIterator
+        var line: [UInt8] = []
+        /// The byte read past a `\r`, to see whether it was `\r\n`.
+        var lookahead: UInt8?
+        var finished = false
+
+        public mutating func next() async throws -> String? {
+            guard !finished else { return nil }
+            while true {
+                let byte: UInt8?
+                if let pending = lookahead {
+                    byte = pending
+                    lookahead = nil
+                } else {
+                    byte = try await base.next()
+                }
+                guard let byte else {
+                    finished = true
+                    if line.isEmpty { return nil }
+                    defer { line = [] }
+                    return String(decoding: line, as: UTF8.self)
+                }
+                switch byte {
+                case UInt8(ascii: "\n"):
+                    defer { line = [] }
+                    return String(decoding: line, as: UTF8.self)
+                case UInt8(ascii: "\r"):
+                    if let following = try await base.next(), following != UInt8(ascii: "\n") {
+                        lookahead = following
+                    }
+                    defer { line = [] }
+                    return String(decoding: line, as: UTF8.self)
+                default:
+                    line.append(byte)
+                }
+            }
+        }
+    }
+
+    public func makeAsyncIterator() -> AsyncIterator {
+        AsyncIterator(base: base.makeAsyncIterator())
+    }
+}
+
+extension AsyncSequence where Element == UInt8 {
+    /// The bytes' lines (UTF-8).
+    public var lines: AsyncLineSequence<Self> { AsyncLineSequence(base: self) }
+}
+
+extension FileHandle {
+    /// The file's bytes from the current offset on, read in chunks.
+    public struct AsyncBytes: AsyncSequence, @unchecked Sendable {
+        public typealias Element = UInt8
+
+        let handle: FileHandle
+
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            let handle: FileHandle
+            var chunk: [UInt8] = []
+            var index = 0
+            var finished = false
+
+            public mutating func next() async throws -> UInt8? {
+                if index == chunk.count {
+                    guard !finished else { return nil }
+                    chunk = Array(try handle.read(upToCount: 64 * 1024) ?? Data())
+                    index = 0
+                    if chunk.isEmpty {
+                        finished = true
+                        return nil
+                    }
+                }
+                defer { index += 1 }
+                return chunk[index]
+            }
+        }
+
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator(handle: handle) }
+    }
+
+    /// The file's bytes, as an async sequence.
+    public var bytes: AsyncBytes { AsyncBytes(handle: self) }
+}
+
+extension URLSession {
+    /// A response body's bytes. The body arrives whole; its bytes are then
+    /// handed out in order.
+    public struct AsyncBytes: AsyncSequence, Sendable {
+        public typealias Element = UInt8
+
+        let data: Data
+
+        public struct AsyncIterator: AsyncIteratorProtocol {
+            var bytes: Data.Iterator
+
+            public mutating func next() async throws -> UInt8? { bytes.next() }
+        }
+
+        public func makeAsyncIterator() -> AsyncIterator { AsyncIterator(bytes: data.makeIterator()) }
+    }
+
+    public func bytes(for request: URLRequest, delegate: (any URLSessionTaskDelegate)? = nil) async throws -> (AsyncBytes, URLResponse) {
+        let (data, response) = try await data(for: request, delegate: delegate)
+        return (AsyncBytes(data: data), response)
+    }
+
+    public func bytes(from url: URL, delegate: (any URLSessionTaskDelegate)? = nil) async throws -> (AsyncBytes, URLResponse) {
+        try await bytes(for: URLRequest(url: url), delegate: delegate)
+    }
+}

package/Sources/FoundationBridge/AsyncImage.swift

@@ -0,0 +1,116 @@
+// `AsyncImage` for the browser. The page loads the picture itself: the view
+// sends an `image` request op with the URL, the host decodes the image (an
+// `<img>` off screen) and answers with its pixel size, and the phase becomes
+// `.success` with an `Image` that renders as an `<img src=url>` the browser
+// already has cached. Nothing of the bitmap crosses into Wasm. Lives here
+// next to `URLSession`, whose errors it reports; `import SwiftUI` brings this
+// module along (the CLI's staging), so it is in scope like Apple's.
+
+import Foundation
+import SwiftUI
+
+/// The current state of an `AsyncImage` load.
+public enum AsyncImagePhase: Sendable {
+    /// No image yet (loading, or the URL was nil).
+    case empty
+    case success(Image)
+    case failure(any Error)
+
+    public var image: Image? {
+        if case .success(let image) = self { return image }
+        return nil
+    }
+
+    public var error: (any Error)? {
+        if case .failure(let error) = self { return error }
+        return nil
+    }
+}
+
+public struct AsyncImage<Content: View>: View {
+    private let url: URL?
+    private let scale: SwiftUI.CGFloat
+    private let content: (AsyncImagePhase) -> Content
+    /// `AsyncImage(url:)`: SwiftUI draws a neutral placeholder until the
+    /// image arrives, and nothing when it fails.
+    private let defaultPlaceholder: Bool
+    @State private var phase: AsyncImagePhase = .empty
+
+    /// Shows the image once loaded, a gray placeholder before.
+    public init(url: URL?, scale: SwiftUI.CGFloat = 1) where Content == Image {
+        self.url = url
+        self.scale = scale
+        self.defaultPlaceholder = true
+        // Never shown for `.empty` (the placeholder takes over) or `.failure` (nothing).
+        self.content = { $0.image ?? Image(_url: "", pixelWidth: 0, pixelHeight: 0, scale: 1) }
+    }
+
+    /// `content` receives the loaded image; `placeholder` shows until then
+    /// (and if the load fails, as in SwiftUI).
+    public init<I: View, P: View>(url: URL?, scale: SwiftUI.CGFloat = 1,
+                                  @ViewBuilder content: @escaping (Image) -> I,
+                                  @ViewBuilder placeholder: @escaping () -> P) where Content == _AsyncImageContent<I, P> {
+        self.url = url
+        self.scale = scale
+        self.defaultPlaceholder = false
+        self.content = { phase in
+            if let image = phase.image { _AsyncImageContent(image: content(image), placeholder: nil) }
+            else { _AsyncImageContent(image: nil, placeholder: placeholder()) }
+        }
+    }
+
+    /// `content` receives every phase.
+    public init(url: URL?, scale: SwiftUI.CGFloat = 1, transaction: Transaction = Transaction(),
+                @ViewBuilder content: @escaping (AsyncImagePhase) -> Content) {
+        self.url = url
+        self.scale = scale
+        self.defaultPlaceholder = false
+        self.content = content
+    }
+
+    public var body: some View {
+        Group {
+            if defaultPlaceholder {
+                switch phase {
+                case .success(let image): image
+                case .empty: Color(red: 0.82, green: 0.82, blue: 0.84)
+                case .failure: EmptyView()
+                }
+            } else {
+                content(phase)
+            }
+        }
+        .task(id: url?.absoluteString ?? "") { await load() }
+    }
+
+    @MainActor
+    private func load() async {
+        guard let url else {
+            phase = .empty
+            return
+        }
+        if case .success = phase { phase = .empty }
+        do {
+            let value = try await _Runtime.shared._hostRequest(kind: "image", params: .object(["url": .string(url.absoluteString)]))
+            guard case .object(let fields) = value, case .number(let width)? = fields["width"], case .number(let height)? = fields["height"] else {
+                phase = .failure(URLError(.cannotDecodeContentData, userInfo: ["NSErrorFailingURLKey": url]))
+                return
+            }
+            phase = .success(Image(_url: url.absoluteString, pixelWidth: width, pixelHeight: height, scale: Double(scale)))
+        } catch let failure as _HostRequestError {
+            phase = .failure(URLSession.urlError(from: failure.message, url: url))
+        } catch {
+            phase = .failure(error)
+        }
+    }
+}
+
+/// What `AsyncImage(url:content:placeholder:)` shows: one of the two.
+public struct _AsyncImageContent<I: View, P: View>: View {
+    let image: I?
+    let placeholder: P?
+
+    public var body: some View {
+        if let image { image } else if let placeholder { placeholder }
+    }
+}

package/Sources/FoundationBridge/AttributedStrings.swift

@@ -0,0 +1,16 @@
+// `NSAttributedString()` and `NSMutableAttributedString()` for the browser.
+// On Apple platforms they inherit NSObject's `init()`, so an empty string is
+// `.init()` (Ice Cubes' composer starts from one); corelibs Foundation's
+// classes only have the `string:` initializers, and an extension cannot
+// declare `init()` (it would override NSObject's). This takes one defaulted
+// parameter instead, which `.init()` and `NSAttributedString()` call alike.
+
+import Foundation
+
+extension NSAttributedString {
+    /// An empty attributed string (`NSAttributedString()`; inherited, so
+    /// `NSMutableAttributedString()` too).
+    public convenience init(_empty: Void = ()) {
+        self.init(string: "")
+    }
+}

package/Sources/{_FoundationCommon → FoundationBridge}/Bundle.swift

@@ -6,7 +6,7 @@
 // answers the resource lookups apps make. Headless runs mount a directory
 // through `SB_BUNDLE_DIR` (scripts/run-wasi.mjs).
 
-import FoundationEssentials
+import Foundation
 import SwiftUI
 
 public final class Bundle: @unchecked Sendable {
@@ -28,6 +28,8 @@ public final class Bundle: @unchecked Sendable {
     public var resourceURL: URL? { bundleURL }
     public var executablePath: String? { nil }
     public var bundleIdentifier: String? { _environment("SB_BUNDLE_ID") }
+    /// None: a web app has no App Store receipt.
+    public var appStoreReceiptURL: URL? { nil }
     public var infoDictionary: [String: Any]? {
         var info: [String: Any] = [:]
         if let id = bundleIdentifier { info["CFBundleIdentifier"] = id }
@@ -74,9 +76,44 @@ public final class Bundle: @unchecked Sendable {
         urls(forResourcesWithExtension: ext, subdirectory: subpath)?.map(\.path) ?? []
     }
 
-    /// No string tables are loaded: the key (or `value` when given) comes back.
+    /// The key's format string in the running language's table
+    /// (`<language>.lproj/<table>.strings` or `.stringsdict`; `Localizable` by
+    /// default), then the development language's; else `value` when not
+    /// empty, else the key (SwiftUI's Localization/Localization.swift).
     public func localizedString(forKey key: String, value: String?, table: String?) -> String {
-        if let value, !value.isEmpty { return value }
-        return key
+        _Localization.localizedString(forKey: key, value: value, table: table, bundlePath: bundlePath)
+    }
+
+    // MARK: Localizations
+
+    /// The language the app was developed in; the CLI stages no other default.
+    public var developmentLocalization: String? { "en" }
+
+    /// The `<name>.lproj` folders among the resources (without `Base`), sorted;
+    /// the development localization alone when the app ships none.
+    public var localizations: [String] {
+        let found = _Localization.localizations(bundlePath: bundlePath)
+        return found.isEmpty ? [developmentLocalization ?? "en"] : found
+    }
+
+    /// The localization the app runs in: the viewer's language as the host
+    /// chose it (`SB_LOCALE`, see docs/ops-protocol.md "Phase 11") matched
+    /// against `localizations`, else the development localization.
+    public var preferredLocalizations: [String] {
+        let preferences = _environment("SB_LOCALE").map { [$0] } ?? []
+        return Bundle.preferredLocalizations(from: localizations, forPreferences: preferences)
+    }
+
+    /// The first of `localizationsArray` that matches the viewer's language.
+    public static func preferredLocalizations(from localizationsArray: [String]) -> [String] {
+        preferredLocalizations(from: localizationsArray, forPreferences: _environment("SB_LOCALE").map { [$0] })
+    }
+
+    /// The first of `localizationsArray` that matches a preference, by whole
+    /// tag (`pt-BR`, case and `_` / `-` aside), Chinese script, then language
+    /// (`pt`); without a match, the development localization when listed, else the first.
+    public static func preferredLocalizations(from localizationsArray: [String],
+                                              forPreferences preferencesArray: [String]?) -> [String] {
+        _Localization.preferredLocalizations(from: localizationsArray, forPreferences: preferencesArray)
     }
 }

package/Sources/FoundationBridge/CombineExports.swift

@@ -0,0 +1,8 @@
+// On Apple platforms Foundation brings Combine's observable-object types
+// along, so a view model that imports only Foundation declares
+// `ObservableObject` and `@Published` (WishKit's `ChatViewModel` does).
+// They are the SwiftUI shim's, which the Combine module shares.
+
+@_exported import protocol SwiftUI.ObservableObject
+@_exported import struct SwiftUI.Published
+@_exported import class SwiftUI.ObservableObjectPublisher

package/Sources/FoundationBridge/CoreFoundation.swift

@@ -0,0 +1,77 @@
+// The Core Foundation clock, which Darwin's Foundation brings along and the
+// WASI SDK's does not (nor does Linux's, publicly). The CLI's staging aliases
+// the names, so code that imports only Foundation finds them.
+
+import Foundation
+// `CFString`, `CFURL`, `CFURLCreateWithString`…: Darwin's Foundation brings
+// CoreFoundation along, so code that imports only Foundation uses them
+// (SwiftSoup parses URLs with CFURL).
+@_exported import CoreFoundationTypes
+
+/// Seconds since 1 January 2001 (GMT), as `Date.timeIntervalSinceReferenceDate`.
+public typealias CFAbsoluteTime = Double
+public typealias CFTimeInterval = Double
+
+public func CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime {
+    Date().timeIntervalSinceReferenceDate
+}
+
+extension NSError {
+    /// The type of `userInfo` keys (`NSErrorUserInfoKey`), which corelibs
+    /// Foundation leaves out. On Apple platforms it is a struct wrapping the
+    /// string; here it is the string, so `[NSError.UserInfoKey: Any]` is
+    /// `[String: Any]` and `key as String` holds.
+    public typealias UserInfoKey = String
+}
+
+/// Runs `body`: there is no Objective-C runtime, so nothing to release early.
+public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result {
+    try body()
+}
+
+// MARK: - Associated objects
+
+/// How an associated value is held. Recorded; values are always retained.
+public enum objc_AssociationPolicy: UInt, Sendable {
+    case OBJC_ASSOCIATION_ASSIGN = 0
+    case OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1
+    case OBJC_ASSOCIATION_COPY_NONATOMIC = 3
+    case OBJC_ASSOCIATION_RETAIN = 769
+    case OBJC_ASSOCIATION_COPY = 771
+}
+
+/// The values attached to objects with `objc_setAssociatedObject`. There is
+/// no Objective-C runtime, so the table is kept here: each object is held
+/// weakly, and the entries of objects that are gone are dropped as the table
+/// changes.
+nonisolated(unsafe) private var _associations: [ObjectIdentifier: (object: _WeakObject, values: [UnsafeRawPointer: Any])] = [:]
+
+private struct _WeakObject {
+    weak var object: AnyObject?
+}
+
+public func objc_setAssociatedObject(_ object: Any, _ key: UnsafeRawPointer, _ value: Any?, _ policy: objc_AssociationPolicy) {
+    let target = object as AnyObject
+    let id = ObjectIdentifier(target)
+    _associations = _associations.filter { $0.value.object.object != nil }
+    var entry = _associations[id] ?? (_WeakObject(object: target), [:])
+    entry.values[key] = value
+    _associations[id] = entry.values.isEmpty ? nil : entry
+}
+
+public func objc_getAssociatedObject(_ object: Any, _ key: UnsafeRawPointer) -> Any? {
+    let target = object as AnyObject
+    guard let entry = _associations[ObjectIdentifier(target)], entry.object.object === target else { return nil }
+    return entry.values[key]
+}
+
+public func objc_removeAssociatedObjects(_ object: Any) {
+    _associations[ObjectIdentifier(object as AnyObject)] = nil
+}
+
+/// An estimate: without the Objective-C runtime there is no instance size to
+/// read, and callers use it to weigh cache costs. Two words of header and six
+/// of storage.
+public func class_getInstanceSize(_ cls: AnyClass?) -> Int {
+    cls == nil ? 0 : 8 * MemoryLayout<Int>.size
+}