@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/FoundationBridge/URLSession.swift

@@ -0,0 +1,718 @@
+// `URLSession` for the browser. swift-corelibs Foundation marks `URLSession`,
+// `URLResponse`, `HTTPURLResponse` and friends unavailable on WASI (they moved
+// to FoundationNetworking, which needs libcurl). These types have the same
+// names and the API apps use; a request becomes a `fetch` request op the page
+// performs with the browser's `fetch`, and the answer comes back as a
+// `response` event (see docs/ops-protocol.md, "Phase 13").
+//
+// What the browser's fetch implies: cross-origin servers must allow the page
+// (CORS), cookies follow the browser's rules, and HTTP errors are responses,
+// not thrown errors, as with Foundation's URLSession. Headless runs answer
+// from `SB_RESPONSES` fixtures (see `_Runtime._hostRequest`).
+
+import Foundation
+import SwiftUI
+
+// MARK: - URLRequest
+
+public struct URLRequest: Equatable, Hashable, Sendable {
+    public enum CachePolicy: UInt, Sendable {
+        case useProtocolCachePolicy = 0
+        case reloadIgnoringLocalCacheData = 1
+        case reloadIgnoringLocalAndRemoteCacheData = 4
+        case returnCacheDataElseLoad = 2
+        case returnCacheDataDontLoad = 3
+        case reloadRevalidatingCacheData = 5
+    }
+
+    public var url: URL?
+    public var cachePolicy: CachePolicy
+    public var timeoutInterval: TimeInterval
+    /// `GET` when nil, as Foundation reads it.
+    public var httpMethod: String? = "GET"
+    public var allHTTPHeaderFields: [String: String]?
+    public var httpBody: Data?
+    public var httpShouldHandleCookies = true
+    public var allowsCellularAccess = true
+
+    public init(url: URL, cachePolicy: CachePolicy = .useProtocolCachePolicy, timeoutInterval: TimeInterval = 60) {
+        self.url = url
+        self.cachePolicy = cachePolicy
+        self.timeoutInterval = timeoutInterval
+    }
+
+    /// Header names compare case-insensitively, as in Foundation.
+    public func value(forHTTPHeaderField field: String) -> String? {
+        allHTTPHeaderFields?.first { $0.key.lowercased() == field.lowercased() }?.value
+    }
+
+    public mutating func setValue(_ value: String?, forHTTPHeaderField field: String) {
+        var headers = allHTTPHeaderFields ?? [:]
+        for key in headers.keys where key.lowercased() == field.lowercased() { headers.removeValue(forKey: key) }
+        if let value { headers[field] = value }
+        allHTTPHeaderFields = headers.isEmpty ? nil : headers
+    }
+
+    public mutating func addValue(_ value: String, forHTTPHeaderField field: String) {
+        if let existing = self.value(forHTTPHeaderField: field) {
+            setValue("\(existing),\(value)", forHTTPHeaderField: field)
+        } else {
+            setValue(value, forHTTPHeaderField: field)
+        }
+    }
+}
+
+// MARK: - Responses
+
+/// Equal and hashed by identity, as an `NSObject` is on Apple platforms.
+open class URLResponse: Hashable, CustomStringConvertible, @unchecked Sendable {
+    public let url: URL?
+    public let mimeType: String?
+    public let expectedContentLength: Int64
+    public let textEncodingName: String?
+
+    public init(url: URL, mimeType: String?, expectedContentLength length: Int, textEncodingName name: String?) {
+        self.url = url
+        self.mimeType = mimeType
+        self.expectedContentLength = Int64(length)
+        self.textEncodingName = name
+    }
+
+    public var suggestedFilename: String? {
+        let name = url?.lastPathComponent ?? ""
+        return name.isEmpty || name == "/" ? "Unknown" : name
+    }
+
+    open var description: String {
+        "<\(type(of: self))> { URL: \(url?.absoluteString ?? "(null)") }"
+    }
+
+    public static func == (lhs: URLResponse, rhs: URLResponse) -> Bool { lhs === rhs }
+    public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}
+
+public final class HTTPURLResponse: URLResponse, @unchecked Sendable {
+    public let statusCode: Int
+    /// Header names as the server sent them (lower-cased by the browser).
+    public let allHeaderFields: [AnyHashable: Any]
+
+    public init?(url: URL, statusCode: Int, httpVersion: String?, headerFields: [String: String]?) {
+        self.statusCode = statusCode
+        var fields: [AnyHashable: Any] = [:]
+        for (key, value) in headerFields ?? [:] { fields[key] = value }
+        allHeaderFields = fields
+        let contentType = headerFields?.first { $0.key.lowercased() == "content-type" }?.value
+        let length = headerFields?.first { $0.key.lowercased() == "content-length" }.flatMap { Int($0.value) } ?? -1
+        super.init(url: url, mimeType: contentType.map(Self.mimeType(of:)), expectedContentLength: length,
+                   textEncodingName: contentType.flatMap(Self.charset(of:)))
+    }
+
+    public func value(forHTTPHeaderField field: String) -> String? {
+        for (key, value) in allHeaderFields {
+            if let name = key.base as? String, name.lowercased() == field.lowercased() { return value as? String }
+        }
+        return nil
+    }
+
+    public class func localizedString(forStatusCode statusCode: Int) -> String {
+        switch statusCode {
+        case 200: "no error"
+        case 201: "created"
+        case 204: "no content"
+        case 301: "moved permanently"
+        case 302: "found"
+        case 304: "not modified"
+        case 400: "bad request"
+        case 401: "unauthorized"
+        case 403: "forbidden"
+        case 404: "not found"
+        case 405: "method not allowed"
+        case 408: "request timeout"
+        case 409: "conflict"
+        case 429: "too many requests"
+        case 500: "internal server error"
+        case 502: "bad gateway"
+        case 503: "service unavailable"
+        case 504: "gateway timeout"
+        case 100..<200: "informational"
+        case 200..<300: "success"
+        case 300..<400: "redirected"
+        case 400..<500: "client error"
+        case 500..<600: "server error"
+        default: "unknown"
+        }
+    }
+
+    private static func mimeType(of contentType: String) -> String {
+        _trimmed(String(contentType.split(separator: ";", maxSplits: 1).first ?? ""))
+    }
+
+    private static func charset(of contentType: String) -> String? {
+        for part in contentType.split(separator: ";").dropFirst() {
+            let pair = part.split(separator: "=", maxSplits: 1).map { _trimmed(String($0)) }
+            if pair.count == 2, pair[0].lowercased() == "charset" { return pair[1].lowercased() }
+        }
+        return nil
+    }
+}
+
+// MARK: - URLError
+
+public struct URLError: Error, Equatable, Hashable, CustomStringConvertible, LocalizedError, Sendable {
+    public struct Code: RawRepresentable, Equatable, Hashable, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+
+        public static let unknown = Code(rawValue: -1)
+        public static let cancelled = Code(rawValue: -999)
+        public static let badURL = Code(rawValue: -1000)
+        public static let timedOut = Code(rawValue: -1001)
+        public static let unsupportedURL = Code(rawValue: -1002)
+        public static let cannotFindHost = Code(rawValue: -1003)
+        public static let cannotConnectToHost = Code(rawValue: -1004)
+        public static let networkConnectionLost = Code(rawValue: -1005)
+        public static let dnsLookupFailed = Code(rawValue: -1006)
+        public static let resourceUnavailable = Code(rawValue: -1008)
+        public static let notConnectedToInternet = Code(rawValue: -1009)
+        public static let badServerResponse = Code(rawValue: -1011)
+        public static let userCancelledAuthentication = Code(rawValue: -1012)
+        public static let zeroByteResource = Code(rawValue: -1014)
+        public static let cannotDecodeRawData = Code(rawValue: -1015)
+        public static let cannotDecodeContentData = Code(rawValue: -1016)
+        public static let cannotParseResponse = Code(rawValue: -1017)
+        public static let internationalRoamingOff = Code(rawValue: -1018)
+        public static let callIsActive = Code(rawValue: -1019)
+        public static let dataNotAllowed = Code(rawValue: -1020)
+        public static let secureConnectionFailed = Code(rawValue: -1200)
+        public static let cannotLoadFromNetwork = Code(rawValue: -2000)
+    }
+
+    public static let errorDomain = "NSURLErrorDomain"
+
+    public let code: Code
+    public let userInfo: [String: any Sendable]
+
+    public init(_ code: Code, userInfo: [String: any Sendable] = [:]) {
+        self.code = code
+        self.userInfo = userInfo
+    }
+
+    public var errorCode: Int { code.rawValue }
+    public var failingURL: URL? { userInfo["NSErrorFailingURLKey"] as? URL }
+
+    public var errorDescription: String? { description }
+    public var localizedDescription: String { description }
+
+    public var description: String {
+        if let message = userInfo["NSLocalizedDescription"] as? String { return message }
+        switch code {
+        case .cancelled: return "cancelled"
+        case .badURL: return "unsupported URL"
+        case .timedOut: return "The request timed out."
+        case .unsupportedURL: return "unsupported URL"
+        case .cannotFindHost: return "A server with the specified hostname could not be found."
+        case .cannotConnectToHost: return "Could not connect to the server."
+        case .networkConnectionLost: return "The network connection was lost."
+        case .notConnectedToInternet: return "The Internet connection appears to be offline."
+        case .badServerResponse: return "The server returned a bad response."
+        case .cannotDecodeContentData, .cannotDecodeRawData: return "The data could not be decoded."
+        case .cannotParseResponse: return "The response could not be parsed."
+        case .secureConnectionFailed: return "An SSL error has occurred and a secure connection to the server cannot be made."
+        case .cannotLoadFromNetwork: return "The resource could not be loaded from the network."
+        default: return "The operation couldn't be completed. (NSURLErrorDomain error \(code.rawValue).)"
+        }
+    }
+
+    public static func == (lhs: URLError, rhs: URLError) -> Bool { lhs.code == rhs.code }
+    public func hash(into hasher: inout Hasher) { hasher.combine(code) }
+}
+
+// MARK: - Configuration and delegates
+
+// Apple declares the delegate methods `@objc optional`, which Swift has
+// only with the Objective-C runtime. Here they are requirements with
+// default implementations that do what URLSession does when a delegate does
+// not implement one (allow the response, follow the redirect, handle the
+// challenge by default, cache the response). The CLI's staging turns the
+// optional calls `delegate?.urlSession?(…)` into `delegate?.urlSession(…)`.
+
+public protocol URLSessionDelegate: AnyObject, Sendable {
+    func urlSession(_ session: URLSession, didBecomeInvalidWithError error: (any Error)?)
+    func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge,
+                    completionHandler: @escaping @Sendable (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
+}
+
+extension URLSessionDelegate {
+    public func urlSession(_ session: URLSession, didBecomeInvalidWithError error: (any Error)?) {}
+    public func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge,
+                           completionHandler: @escaping @Sendable (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        completionHandler(.performDefaultHandling, nil)
+    }
+}
+
+public protocol URLSessionTaskDelegate: URLSessionDelegate {
+    func urlSession(_ session: URLSession, didCreateTask task: URLSessionTask)
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: (any Error)?)
+    func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics)
+    func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest, completionHandler: @escaping @Sendable (URLRequest?) -> Void)
+    func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask)
+    func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge,
+                    completionHandler: @escaping @Sendable (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
+    func urlSession(_ session: URLSession, task: URLSessionTask, willBeginDelayedRequest request: URLRequest,
+                    completionHandler: @escaping @Sendable (URLSession.DelayedRequestDisposition, URLRequest?) -> Void)
+}
+
+extension URLSessionTaskDelegate {
+    public func urlSession(_ session: URLSession, didCreateTask task: URLSessionTask) {}
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: (any Error)?) {}
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didFinishCollecting metrics: URLSessionTaskMetrics) {}
+    public func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
+                           newRequest request: URLRequest, completionHandler: @escaping @Sendable (URLRequest?) -> Void) {
+        completionHandler(request)
+    }
+    public func urlSession(_ session: URLSession, taskIsWaitingForConnectivity task: URLSessionTask) {}
+    public func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge,
+                           completionHandler: @escaping @Sendable (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        completionHandler(.performDefaultHandling, nil)
+    }
+    public func urlSession(_ session: URLSession, task: URLSessionTask, willBeginDelayedRequest request: URLRequest,
+                           completionHandler: @escaping @Sendable (URLSession.DelayedRequestDisposition, URLRequest?) -> Void) {
+        completionHandler(.continueLoading, nil)
+    }
+}
+
+public protocol URLSessionDataDelegate: URLSessionTaskDelegate {
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse,
+                    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void)
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data)
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, willCacheResponse proposedResponse: CachedURLResponse,
+                    completionHandler: @escaping @Sendable (CachedURLResponse?) -> Void)
+}
+
+extension URLSessionDataDelegate {
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse,
+                           completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        completionHandler(.allow)
+    }
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {}
+    public func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, willCacheResponse proposedResponse: CachedURLResponse,
+                           completionHandler: @escaping @Sendable (CachedURLResponse?) -> Void) {
+        completionHandler(proposedResponse)
+    }
+}
+
+/// A server's request for credentials. The browser handles authentication
+/// itself, so a session never asks; the types exist for delegates' signatures.
+public final class URLAuthenticationChallenge: @unchecked Sendable {
+    public let protectionSpace: URLProtectionSpace
+    public let proposedCredential: URLCredential?
+    public let previousFailureCount: Int
+
+    public init(protectionSpace: URLProtectionSpace, proposedCredential: URLCredential?, previousFailureCount: Int) {
+        self.protectionSpace = protectionSpace
+        self.proposedCredential = proposedCredential
+        self.previousFailureCount = previousFailureCount
+    }
+}
+
+public final class URLProtectionSpace: @unchecked Sendable {
+    public let host: String
+    public let port: Int
+    public let `protocol`: String?
+    public let realm: String?
+    public let authenticationMethod: String
+
+    public init(host: String, port: Int, protocol: String?, realm: String?, authenticationMethod: String?) {
+        self.host = host
+        self.port = port
+        self.protocol = `protocol`
+        self.realm = realm
+        self.authenticationMethod = authenticationMethod ?? "NSURLAuthenticationMethodDefault"
+    }
+}
+
+public final class URLCredential: @unchecked Sendable {
+    public enum Persistence: UInt, Sendable { case none, forSession, permanent, synchronizable }
+
+    public let user: String?
+    public let password: String?
+    public let persistence: Persistence
+    public var hasPassword: Bool { password != nil }
+
+    public init(user: String, password: String, persistence: Persistence) {
+        self.user = user
+        self.password = password
+        self.persistence = persistence
+    }
+}
+
+/// Timing of a task. The browser does not report it: one transaction, no timings.
+public final class URLSessionTaskMetrics: @unchecked Sendable {
+    public let taskInterval: DateInterval
+    public let redirectCount: Int
+    public let transactionMetrics: [Any]
+
+    init(start: Date) {
+        taskInterval = DateInterval(start: start, end: Date())
+        redirectCount = 0
+        transactionMetrics = []
+    }
+}
+
+/// A response with its body, as a cache stores it.
+public final class CachedURLResponse: @unchecked Sendable {
+    public enum StoragePolicy: UInt, Sendable { case allowed, allowedInMemoryOnly, notAllowed }
+
+    public let response: URLResponse
+    public let data: Data
+    public let userInfo: [AnyHashable: Any]?
+    public let storagePolicy: StoragePolicy
+
+    public init(response: URLResponse, data: Data, userInfo: [AnyHashable: Any]? = nil, storagePolicy: StoragePolicy = .allowed) {
+        self.response = response
+        self.data = data
+        self.userInfo = userInfo
+        self.storagePolicy = storagePolicy
+    }
+}
+
+/// The HTTP cache: the browser's, which every `fetch` goes through. This
+/// object only records its capacities; it stores nothing itself.
+public final class URLCache: @unchecked Sendable {
+    nonisolated(unsafe) public static var shared = URLCache(memoryCapacity: 0, diskCapacity: 0, diskPath: nil)
+
+    public var memoryCapacity: Int
+    public var diskCapacity: Int
+    public var currentMemoryUsage: Int { 0 }
+    public var currentDiskUsage: Int { 0 }
+
+    public init(memoryCapacity: Int, diskCapacity: Int, diskPath path: String?) {
+        self.memoryCapacity = memoryCapacity
+        self.diskCapacity = diskCapacity
+    }
+
+    public init(memoryCapacity: Int, diskCapacity: Int, directory: URL? = nil) {
+        self.memoryCapacity = memoryCapacity
+        self.diskCapacity = diskCapacity
+    }
+
+    public func cachedResponse(for request: URLRequest) -> CachedURLResponse? { nil }
+    public func storeCachedResponse(_ cachedResponse: CachedURLResponse, for request: URLRequest) {}
+    public func removeCachedResponse(for request: URLRequest) {}
+    public func removeAllCachedResponses() {}
+    public func removeCachedResponses(since date: Date) {}
+}
+
+public final class URLSessionConfiguration: @unchecked Sendable {
+    public static var `default`: URLSessionConfiguration { URLSessionConfiguration() }
+    public static var ephemeral: URLSessionConfiguration { URLSessionConfiguration() }
+    public static func background(withIdentifier identifier: String) -> URLSessionConfiguration { URLSessionConfiguration() }
+
+    public var timeoutIntervalForRequest: TimeInterval = 60
+    public var timeoutIntervalForResource: TimeInterval = 7 * 24 * 60 * 60
+    public var httpAdditionalHeaders: [AnyHashable: Any]?
+    public var requestCachePolicy: URLRequest.CachePolicy = .useProtocolCachePolicy
+    public var waitsForConnectivity = false
+    public var allowsCellularAccess = true
+    public var httpShouldSetCookies = true
+    public var httpMaximumConnectionsPerHost = 6
+    public var urlCache: URLCache? = .shared
+
+    public init() {}
+}
+
+// MARK: - Tasks
+
+open class URLSessionTask: Hashable, @unchecked Sendable {
+    public enum State: Int, Sendable { case running, suspended, canceling, completed }
+
+    public let taskIdentifier: Int
+    public let originalRequest: URLRequest?
+    public private(set) var state: State = .suspended
+    public var taskDescription: String?
+    public var priority: Float = 0.5
+    /// Accepted: the browser hands over the whole body at once.
+    public var prefersIncrementalDelivery = true
+    public var currentRequest: URLRequest? { originalRequest }
+    public internal(set) var countOfBytesReceived: Int64 = 0
+    public var countOfBytesExpectedToReceive: Int64 { response?.expectedContentLength ?? -1 }
+
+    public static func == (lhs: URLSessionTask, rhs: URLSessionTask) -> Bool { lhs === rhs }
+    public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+    public private(set) var response: URLResponse?
+    public private(set) var error: (any Error)?
+
+    private let work: @MainActor @Sendable (URLSessionTask) async -> Void
+    private var running: Task<Void, Never>?
+
+    init(identifier: Int, request: URLRequest?, work: @escaping @MainActor @Sendable (URLSessionTask) async -> Void) {
+        taskIdentifier = identifier
+        originalRequest = request
+        self.work = work
+    }
+
+    /// Starts the request; the completion handler runs on the main actor
+    /// (Wasm is single-threaded) once the host answers.
+    public func resume() {
+        guard state == .suspended else { return }
+        state = .running
+        running = Task { @MainActor [self] in await work(self) }
+    }
+
+    open func cancel() {
+        guard state == .running || state == .suspended else { return }
+        state = .canceling
+        running?.cancel()
+    }
+
+    public func suspend() {}
+
+    func receive(response: URLResponse) {
+        self.response = response
+    }
+
+    func finish(response: URLResponse?, error: (any Error)?) {
+        self.response = response
+        self.error = error
+        state = .completed
+    }
+}
+
+public final class URLSessionDataTask: URLSessionTask, @unchecked Sendable {}
+public final class URLSessionUploadTask: URLSessionTask, @unchecked Sendable {}
+
+// MARK: - URLSession
+
+public final class URLSession: @unchecked Sendable {
+    nonisolated(unsafe) public static let shared = URLSession(configuration: .default)
+
+    public let configuration: URLSessionConfiguration
+    public var sessionDescription: String?
+    /// Retained until the session is invalidated, as URLSession does.
+    public private(set) var delegate: (any URLSessionDelegate)?
+    /// Where delegate methods run (all on the main actor).
+    public let delegateQueue: OperationQueue
+    private var nextTaskIdentifier = 1
+
+    public init(configuration: URLSessionConfiguration) {
+        self.configuration = configuration
+        self.delegateQueue = OperationQueue()
+        delegateQueue.maxConcurrentOperationCount = 1
+    }
+
+    public init(configuration: URLSessionConfiguration, delegate: (any URLSessionDelegate)?, delegateQueue: OperationQueue?) {
+        self.configuration = configuration
+        self.delegate = delegate
+        self.delegateQueue = delegateQueue ?? OperationQueue()
+        if delegateQueue == nil { self.delegateQueue.maxConcurrentOperationCount = 1 }
+    }
+
+    public func finishTasksAndInvalidate() { invalidate(nil) }
+    public func invalidateAndCancel() { invalidate(nil) }
+
+    private func invalidate(_ error: (any Error)?) {
+        guard let delegate else { return }
+        self.delegate = nil
+        delegateQueue.addOperation { delegate.urlSession(self, didBecomeInvalidWithError: error) }
+    }
+
+    // MARK: Swift concurrency
+
+    // Apple declares the forms without a delegate too (iOS 15); a protocol
+    // that requires `data(from:)` finds them.
+    public func data(from url: URL) async throws -> (Data, URLResponse) {
+        try await data(from: url, delegate: nil)
+    }
+
+    public func data(for request: URLRequest) async throws -> (Data, URLResponse) {
+        try await data(for: request, delegate: nil)
+    }
+
+    public func data(from url: URL, delegate: (any URLSessionTaskDelegate)? = nil) async throws -> (Data, URLResponse) {
+        try await data(for: URLRequest(url: url))
+    }
+
+    public func data(for request: URLRequest, delegate: (any URLSessionTaskDelegate)? = nil) async throws -> (Data, URLResponse) {
+        try await perform(request, body: request.httpBody)
+    }
+
+    public func upload(for request: URLRequest, from bodyData: Data, delegate: (any URLSessionTaskDelegate)? = nil) async throws -> (Data, URLResponse) {
+        var request = request
+        if request.httpMethod == nil || request.httpMethod == "GET" { request.httpMethod = "POST" }
+        return try await perform(request, body: bodyData)
+    }
+
+    // MARK: Completion handlers
+
+    public func dataTask(with url: URL, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask {
+        dataTask(with: URLRequest(url: url), completionHandler: completionHandler)
+    }
+
+    public func dataTask(with request: URLRequest, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionDataTask {
+        let task = URLSessionDataTask(identifier: takeIdentifier(), request: request) { [self] task in
+            do {
+                let (data, response) = try await perform(request, body: request.httpBody)
+                task.finish(response: response, error: nil)
+                completionHandler(data, response, nil)
+            } catch {
+                let failure: any Error = Task.isCancelled ? URLError(.cancelled) : error
+                task.finish(response: nil, error: failure)
+                completionHandler(nil, nil, failure)
+            }
+        }
+        return task
+    }
+
+    // MARK: Delegate tasks
+
+    public func dataTask(with url: URL) -> URLSessionDataTask {
+        dataTask(with: URLRequest(url: url))
+    }
+
+    /// A task that reports to the session's delegate: the response (which the
+    /// delegate may cancel), the body in one piece, then completion.
+    public func dataTask(with request: URLRequest) -> URLSessionDataTask {
+        let started = Date()
+        let task = URLSessionDataTask(identifier: takeIdentifier(), request: request) { [self] task in
+            let dataTask = task as! URLSessionDataTask
+            let delegate = self.delegate
+            do {
+                let (data, response) = try await perform(request, body: request.httpBody)
+                if Task.isCancelled { throw URLError(.cancelled) }
+                task.receive(response: response)
+                let disposition: ResponseDisposition = await withCheckedContinuation { continuation in
+                    nonisolated(unsafe) let resume = continuation
+                    self.delegateQueue.addOperation {
+                        guard let delegate = delegate as? any URLSessionDataDelegate else { return resume.resume(returning: .allow) }
+                        var answered = false
+                        delegate.urlSession(self, dataTask: dataTask, didReceive: response) { disposition in
+                            guard !answered else { return }
+                            answered = true
+                            resume.resume(returning: disposition)
+                        }
+                    }
+                }
+                guard disposition == .allow, !Task.isCancelled else { throw URLError(.cancelled) }
+                task.countOfBytesReceived = Int64(data.count)
+                task.finish(response: response, error: nil)
+                delegateQueue.addOperation {
+                    guard let delegate = delegate as? any URLSessionTaskDelegate else { return }
+                    if !data.isEmpty { (delegate as? any URLSessionDataDelegate)?.urlSession(self, dataTask: dataTask, didReceive: data) }
+                    delegate.urlSession(self, task: dataTask, didFinishCollecting: URLSessionTaskMetrics(start: started))
+                    delegate.urlSession(self, task: dataTask, didCompleteWithError: nil)
+                }
+            } catch {
+                let failure: any Error = Task.isCancelled ? URLError(.cancelled) : error
+                task.finish(response: task.response, error: failure)
+                delegateQueue.addOperation {
+                    (delegate as? any URLSessionTaskDelegate)?.urlSession(self, task: dataTask, didCompleteWithError: failure)
+                }
+            }
+        }
+        if let delegate = delegate as? any URLSessionTaskDelegate {
+            delegateQueue.addOperation { delegate.urlSession(self, didCreateTask: task) }
+        }
+        return task
+    }
+
+    public enum ResponseDisposition: Int, Sendable { case cancel, allow, becomeDownload, becomeStream }
+    public enum AuthChallengeDisposition: Int, Sendable { case useCredential, performDefaultHandling, cancelAuthenticationChallenge, rejectProtectionSpace }
+    public enum DelayedRequestDisposition: Int, Sendable { case continueLoading, useNewRequest, cancel }
+
+    public func uploadTask(with request: URLRequest, from bodyData: Data, completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void) -> URLSessionUploadTask {
+        var upload = request
+        upload.httpBody = bodyData
+        if upload.httpMethod == nil || upload.httpMethod == "GET" { upload.httpMethod = "POST" }
+        let request = upload
+        let task = URLSessionUploadTask(identifier: takeIdentifier(), request: request) { [self] task in
+            do {
+                let (data, response) = try await perform(request, body: bodyData)
+                task.finish(response: response, error: nil)
+                completionHandler(data, response, nil)
+            } catch {
+                task.finish(response: nil, error: error)
+                completionHandler(nil, nil, error)
+            }
+        }
+        return task
+    }
+
+    func takeIdentifier() -> Int {
+        defer { nextTaskIdentifier += 1 }
+        return nextTaskIdentifier
+    }
+
+    // MARK: The host request
+
+    /// Sends the request to the host and turns its answer into Foundation's
+    /// shapes. Non-2xx statuses are responses, not errors; failures to reach
+    /// the server (including CORS refusals, which the browser reports as a
+    /// network error) are `URLError`s.
+    private func perform(_ request: URLRequest, body: Data?) async throws -> (Data, URLResponse) {
+        guard let url = request.url else { throw URLError(.badURL) }
+        guard let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" else {
+            throw URLError(.unsupportedURL, userInfo: ["NSErrorFailingURLKey": url])
+        }
+        var headers: [String: String] = [:]
+        for (key, value) in configuration.httpAdditionalHeaders ?? [:] {
+            if let name = key.base as? String, let text = value as? String { headers[name] = text }
+        }
+        for (key, value) in request.allHTTPHeaderFields ?? [:] { headers[key] = value }
+        let timeout = request.timeoutInterval > 0 ? min(request.timeoutInterval, configuration.timeoutIntervalForRequest) : configuration.timeoutIntervalForRequest
+        // OAuth redirects to the app's own URL scheme name the page's callback
+        // page instead (WebAuthRedirects.swift; docs/ops-protocol.md, "Signing in").
+        let sentURL = _WebAuthRedirects.rewriting(url: url)
+        let sentBody = _WebAuthRedirects.rewriting(body: body, contentType: headers.first { $0.key.lowercased() == "content-type" }?.value)
+        let params: _JSON = .object([
+            "url": .string(sentURL.absoluteString),
+            "method": .string(request.httpMethod ?? "GET"),
+            "headers": .object(headers.mapValues { .string($0) }),
+            "body": sentBody.map { .string($0.base64EncodedString()) } ?? .null,
+            "timeout": .number(timeout * 1000),
+        ])
+
+        let value: _JSON
+        do {
+            value = try await _Runtime.shared._hostRequest(kind: "fetch", params: params)
+        } catch let failure as _HostRequestError {
+            throw Self.urlError(from: failure.message, url: url)
+        }
+        guard case .object(let fields) = value else { throw URLError(.badServerResponse, userInfo: ["NSErrorFailingURLKey": url]) }
+
+        var status = 200
+        if case .number(let n)? = fields["status"] { status = Int(n) }
+        var responseHeaders: [String: String] = [:]
+        if case .object(let raw)? = fields["headers"] {
+            for (key, item) in raw { if case .string(let text) = item { responseHeaders[key] = text } }
+        }
+        var data = Data()
+        if case .bytes(let bytes)? = fields["body"] {
+            // From the page, through linear memory (docs/ops-protocol.md, "Bytes").
+            data = Data(bytes)
+        } else if case .string(let encoded)? = fields["body"], !encoded.isEmpty {
+            guard let decoded = Data(base64Encoded: encoded) else { throw URLError(.cannotDecodeRawData, userInfo: ["NSErrorFailingURLKey": url]) }
+            data = decoded
+        }
+        var finalURL = url
+        if case .string(let text)? = fields["url"], let parsed = URL(string: text) { finalURL = parsed }
+        guard let response = HTTPURLResponse(url: finalURL, statusCode: status, httpVersion: "HTTP/1.1", headerFields: responseHeaders) else {
+            throw URLError(.badServerResponse, userInfo: ["NSErrorFailingURLKey": url])
+        }
+        return (data, response)
+    }
+
+    /// The host reports failures as short messages (see Web/src/hostRequests.ts).
+    static func urlError(from message: String, url: URL) -> URLError {
+        let lowered = message.lowercased()
+        let code: URLError.Code = if lowered.hasPrefix("timeout") { .timedOut }
+            else if lowered.hasPrefix("abort") || lowered.hasPrefix("cancel") { .cancelled }
+            else if lowered.hasPrefix("offline") { .notConnectedToInternet }
+            else if lowered.hasPrefix("headless") { .cannotLoadFromNetwork }
+            else { .cannotConnectToHost }
+        return URLError(code, userInfo: ["NSErrorFailingURLKey": url, "NSLocalizedDescription": "\(URLError(code).description) (\(message))"])
+    }
+}
+
+/// Leading and trailing spaces and tabs removed.
+func _trimmed(_ text: String) -> String { text.trimmingCharacters(in: .whitespaces) }